Package evaluation to test LabelledArrays on Julia 1.14.0-DEV.2116 (f310e68148*) started at 2026-05-06T21:14:37.554


################################################################################
# Set-up
#

Installing PkgEval dependencies (TestEnv)...
  Activating project at `~/.julia/environments/v1.14`

Set-up completed after 15.07s


################################################################################
# Installation
#

Installing LabelledArrays...
   Resolving package versions...
    Updating `~/.julia/environments/v1.14/Project.toml`
  [2ee39098] + LabelledArrays v1.19.0
    Updating `~/.julia/environments/v1.14/Manifest.toml`
  [7d9f7c33] + Accessors v0.1.44
  [79e6a3ab] + Adapt v4.5.2
  [4fba245c] + ArrayInterface v7.24.0
  [d360d2e6] + ChainRulesCore v1.26.1
  [bbf7d656] + CommonSubexpressions v0.3.1
  [34da2185] + Compat v4.18.1
  [a33af91c] + CompositionsBase v0.1.2
  [187b0558] + ConstructionBase v1.6.0
  [163ba53b] + DiffResults v1.1.0
  [b552c78f] + DiffRules v1.15.1
  [ffbed154] + DocStringExtensions v0.9.5
  [e2ba6199] + ExprTools v0.1.10
  [f6369f11] + ForwardDiff v1.3.3
  [46192b85] + GPUArraysCore v0.2.0
  [3587e190] + InverseFunctions v0.1.17
  [92d709cd] + IrrationalConstants v0.2.6
  [692b3bcd] + JLLWrappers v1.7.1
  [2ee39098] + LabelledArrays v1.19.0
  [2ab3a3ac] + LogExpFunctions v0.3.29
  [1914dd2f] + MacroTools v0.5.16
  [77ba4419] + NaNMath v1.1.3
  [d236fae5] + PreallocationTools v1.2.0
  [aea7be01] + PrecompileTools v1.3.3
  [21216c6a] + Preferences v1.5.2
  [3cdcf5f2] + RecipesBase v1.3.4
  [731186ca] + RecursiveArrayTools v4.3.0
  [ae029012] + Requires v1.3.1
  [7e49a35a] + RuntimeGeneratedFunctions v0.5.18
  [276daf66] + SpecialFunctions v2.7.2
  [90137ffa] + StaticArrays v1.9.18
  [1e83bf80] + StaticArraysCore v1.4.4
  [2efcf032] + SymbolicIndexingInterface v0.3.47
  [efe28fd5] + OpenSpecFun_jll v0.5.6+0
  [56f22d72] + Artifacts v1.11.0
  [ade2ca70] + Dates v1.11.0
  [8f399da3] + Libdl v1.11.0
  [37e2e46d] + LinearAlgebra v1.13.0
  [de0858da] + Printf v1.11.0
  [9a3f8284] + Random v1.11.0
  [ea8e919c] + SHA v1.0.0
  [9e88b42a] + Serialization v1.11.0
  [fa267f1f] + TOML v1.0.3
  [cf7118a7] + UUIDs v1.11.0
  [4ec0a83e] + Unicode v1.11.0
  [e66e0078] + CompilerSupportLibraries_jll v1.5.1+0
  [4536629a] + OpenBLAS_jll v0.3.33+0
  [05823500] + OpenLibm_jll v0.8.7+0
  [8e850b90] + libblastrampoline_jll v5.15.0+0

Installation completed after 5.77s


################################################################################
# Precompilation
#

Precompiling PkgEval dependencies...

Precompiling package dependencies...
Precompiling project...
   3.1 s  ✓ DifferentiationInterface → DifferentiationInterfaceFiniteDifferencesExt
  12.0 s  ✓ SciMLJacobianOperators
   1.5 s  ✓ FastPower → FastPowerForwardDiffExt
  21.5 s  ✓ LinearSolve
   6.7 s  ✓ LabelledArrays
  14.6 s  ✓ LineSearch
  20.1 s  ✓ NonlinearSolveBase
   4.9 s  ✓ LinearSolve → LinearSolveChainRulesCoreExt
  10.0 s  ✓ LinearSolve → LinearSolveSparseArraysExt
   9.2 s  ✓ LinearSolve → LinearSolveForwardDiffExt
   5.1 s  ✓ NonlinearSolveBase → NonlinearSolveBaseSparseMatrixColoringsExt
   4.9 s  ✓ NonlinearSolveBase → NonlinearSolveBaseSparseArraysExt
   4.6 s  ✓ NonlinearSolveBase → NonlinearSolveBaseChainRulesCoreExt
   5.2 s  ✓ NonlinearSolveBase → NonlinearSolveBaseLinearSolveExt
   4.2 s  ✓ NonlinearSolveBase → NonlinearSolveBaseLineSearchExt
  13.2 s  ✓ NonlinearSolveBase → NonlinearSolveBaseForwardDiffExt
  10.5 s  ✓ BracketingNonlinearSolve
   5.7 s  ✓ LinearSolve → LinearSolveEnzymeExt
  20.1 s  ✓ NonlinearSolveSpectralMethods
   4.6 s  ✓ BracketingNonlinearSolve → BracketingNonlinearSolveForwardDiffExt
   9.9 s  ✓ DiffEqBase
  29.8 s  ✓ NonlinearSolveQuasiNewton
  51.6 s  ✓ NonlinearSolveFirstOrder
   5.6 s  ✓ NonlinearSolveSpectralMethods → NonlinearSolveSpectralMethodsForwardDiffExt
   4.2 s  ✓ BracketingNonlinearSolve → BracketingNonlinearSolveChainRulesCoreExt
  20.0 s  ✓ SimpleNonlinearSolve
   4.6 s  ✓ DiffEqBase → DiffEqBaseSparseArraysExt
   4.1 s  ✓ DiffEqBase → DiffEqBaseChainRulesCoreExt
   9.7 s  ✓ DiffEqBase → DiffEqBaseForwardDiffExt
  10.6 s  ✓ OrdinaryDiffEqCore
   6.2 s  ✓ NonlinearSolveQuasiNewton → NonlinearSolveQuasiNewtonForwardDiffExt
   4.5 s  ✓ SimpleNonlinearSolve → SimpleNonlinearSolveChainRulesCoreExt
   4.6 s  ✓ OrdinaryDiffEqCore → OrdinaryDiffEqCoreSparseArraysExt
  53.7 s  ✓ OrdinaryDiffEqVerner
  15.6 s  ✓ OrdinaryDiffEqTsit5
  91.8 s  ✓ NonlinearSolve
ERROR: LoadError: Precompiled image Base.PkgId(Base.UUID("ce17a24b-f985-5b8c-be07-4b97333c7055"), "NonlinearSolveBaseLinearSolveExt") not available with flags CacheFlags(; use_pkgimages=false, debug_level=1, check_bounds=1, inline=true, opt_level=0)
Stacktrace:
  [1] error(s::String)
    @ Base ./error.jl:56
  [2] __require_prelocked(pkg::Base.PkgId, env::Nothing)
    @ Base ./loading.jl:2818
  [3] _require_prelocked(uuidkey::Base.PkgId, env::Nothing)
    @ Base ./loading.jl:2672
  [4] assert_havelock(l::ReentrantLock)
    @ Base ./loading.jl:2666 [inlined]
  [5] run_extension_callbacks(extid::Base.ExtensionId)
    @ Base ./loading.jl:1769
  [6] run_extension_callbacks(pkgid::Base.PkgId)
    @ Base ./loading.jl:1806
  [7] run_package_callbacks(modkey::Base.PkgId)
    @ Base ./loading.jl:1622
  [8] _require_search_from_serialized(pkg::Base.PkgId, sourcespec::Base.PkgLoadSpec, build_id::UInt128, stalecheck::Bool; reasons::Dict{String, Int64}, DEPOT_PATH::Vector{String})
    @ Base ./loading.jl:2301
  [9] !=(x::Int8, y::Int64)
    @ Base ./loading.jl:2178 [inlined]
 [10] __require_prelocked(pkg::Base.PkgId, env::String)
    @ Base ./loading.jl:2811
 [11] _require_prelocked(uuidkey::Base.PkgId, env::String)
    @ Base ./loading.jl:2672
 [12] macro expansion
    @ ./loading.jl:2599 [inlined]
 [13] String(s::Symbol)
    @ Base ./lock.jl:376 [inlined]
 [14] __require(into::Module, mod::Symbol)
    @ Base ./loading.jl:2563
 [15] require(into::Module, mod::Symbol)
    @ Base ./loading.jl:2539 [inlined]
 [16] eval_import_path(at::Module, from::Nothing, path::Expr, keyword::String)
    @ Base ./module.jl:36 [inlined]
 [17] _eval_import(imported::Bool, to::Module, from::Nothing, paths::Expr)
    @ Base ./module.jl:111
 [18] top-level scope
    @ ~/.julia/packages/OrdinaryDiffEqDifferentiation/9LW4F/src/OrdinaryDiffEqDifferentiation.jl:11
 [19] include(mod::Module, _path::String)
    @ Base ./Base.jl:326
 [20] include_package_for_output(pkg::Base.PkgId, input::String, syntax_version::VersionNumber, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)
    @ Base ./loading.jl:3271
 [21] top-level scope
    @ stdin:5
 [22] eval(m::Module, e::Any)
    @ Core ./boot.jl:517
 [23] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
    @ Base ./loading.jl:3113
 [24] materialize(bc::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, Type{Symbol}, Tuple{Vector{SubString{String}}}})
    @ Base.Broadcast ./loading.jl:3123 [inlined]
 [25] exec_options(opts::Base.JLOptions)
    @ Base ./client.jl:350
 [26] _start()
    @ Base ./client.jl:593
in expression starting at /home/pkgeval/.julia/packages/OrdinaryDiffEqDifferentiation/9LW4F/src/OrdinaryDiffEqDifferentiation.jl:1
in expression starting at stdin:5
              ✗ OrdinaryDiffEqDifferentiation
   6.6 s  ✓ OrdinaryDiffEqDifferentiation → OrdinaryDiffEqDifferentiationSparseArraysExt
ERROR: LoadError: Precompiled image Base.PkgId(Base.UUID("ce17a24b-f985-5b8c-be07-4b97333c7055"), "NonlinearSolveBaseLinearSolveExt") not available with flags CacheFlags(; use_pkgimages=false, debug_level=1, check_bounds=1, inline=true, opt_level=0)
Stacktrace:
  [1] error(s::String)
    @ Base ./error.jl:56
  [2] __require_prelocked(pkg::Base.PkgId, env::Nothing)
    @ Base ./loading.jl:2818
  [3] _require_prelocked(uuidkey::Base.PkgId, env::Nothing)
    @ Base ./loading.jl:2672
  [4] assert_havelock(l::ReentrantLock)
    @ Base ./loading.jl:2666 [inlined]
  [5] run_extension_callbacks(extid::Base.ExtensionId)
    @ Base ./loading.jl:1769
  [6] run_extension_callbacks(pkgid::Base.PkgId)
    @ Base ./loading.jl:1806
  [7] run_package_callbacks(modkey::Base.PkgId)
    @ Base ./loading.jl:1622
  [8] _require_prelocked(uuidkey::Base.PkgId, env::String)
    @ Base ./loading.jl:2680
  [9] macro expansion
    @ ./loading.jl:2599 [inlined]
 [10] String(s::Symbol)
    @ Base ./lock.jl:376 [inlined]
 [11] __require(into::Module, mod::Symbol)
    @ Base ./loading.jl:2563
 [12] require(into::Module, mod::Symbol)
    @ Base ./loading.jl:2539 [inlined]
 [13] eval_import_path(at::Module, from::Nothing, path::Expr, keyword::String)
    @ Base ./module.jl:36 [inlined]
 [14] _eval_import(imported::Bool, to::Module, from::Nothing, paths::Expr)
    @ Base ./module.jl:111
 [15] top-level scope
    @ ~/.julia/packages/OrdinaryDiffEqRosenbrock/8B1Sy/src/OrdinaryDiffEqRosenbrock.jl:22
 [16] include(mod::Module, _path::String)
    @ Base ./Base.jl:326
 [17] include_package_for_output(pkg::Base.PkgId, input::String, syntax_version::VersionNumber, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)
    @ Base ./loading.jl:3271
 [18] top-level scope
    @ stdin:5
 [19] eval(m::Module, e::Any)
    @ Core ./boot.jl:517
 [20] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
    @ Base ./loading.jl:3113
 [21] materialize(bc::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, Type{Symbol}, Tuple{Vector{SubString{String}}}})
    @ Base.Broadcast ./loading.jl:3123 [inlined]
 [22] exec_options(opts::Base.JLOptions)
    @ Base ./client.jl:350
 [23] _start()
    @ Base ./client.jl:593
in expression starting at /home/pkgeval/.julia/packages/OrdinaryDiffEqRosenbrock/8B1Sy/src/OrdinaryDiffEqRosenbrock.jl:1
in expression starting at stdin:5
              ✗ OrdinaryDiffEqRosenbrock
ERROR: LoadError: Precompiled image Base.PkgId(Base.UUID("4302a76b-040a-498a-8c04-15b101fed76b"), "OrdinaryDiffEqDifferentiation") not available with flags CacheFlags(; use_pkgimages=false, debug_level=1, check_bounds=1, inline=true, opt_level=0)
Stacktrace:
  [1] error(s::String)
    @ Base ./error.jl:56
  [2] __require_prelocked(pkg::Base.PkgId, env::String)
    @ Base ./loading.jl:2818
  [3] _require_prelocked(uuidkey::Base.PkgId, env::String)
    @ Base ./loading.jl:2672
  [4] macro expansion
    @ ./loading.jl:2599 [inlined]
  [5] String(s::Symbol)
    @ Base ./lock.jl:376 [inlined]
  [6] __require(into::Module, mod::Symbol)
    @ Base ./loading.jl:2563
  [7] require(into::Module, mod::Symbol)
    @ Base ./loading.jl:2539 [inlined]
  [8] eval_import_path(at::Module, from::Nothing, path::Expr, keyword::String)
    @ Base ./module.jl:36 [inlined]
  [9] eval_import_path_all(at::Module, path::Expr, keyword::String)
    @ Base ./module.jl:60
 [10] _eval_import(::Bool, ::Module, ::Expr, ::Expr, ::Vararg{Expr})
    @ Base ./module.jl:101
 [11] top-level scope
    @ ~/.julia/packages/OrdinaryDiffEqNonlinearSolve/g0Xmj/src/OrdinaryDiffEqNonlinearSolve.jl:58
 [12] include(mod::Module, _path::String)
    @ Base ./Base.jl:326
 [13] include_package_for_output(pkg::Base.PkgId, input::String, syntax_version::VersionNumber, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)
    @ Base ./loading.jl:3271
 [14] top-level scope
    @ stdin:5
 [15] eval(m::Module, e::Any)
    @ Core ./boot.jl:517
 [16] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
    @ Base ./loading.jl:3113
 [17] materialize(bc::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, Type{Symbol}, Tuple{Vector{SubString{String}}}})
    @ Base.Broadcast ./loading.jl:3123 [inlined]
 [18] exec_options(opts::Base.JLOptions)
    @ Base ./client.jl:350
 [19] _start()
    @ Base ./client.jl:593
in expression starting at /home/pkgeval/.julia/packages/OrdinaryDiffEqNonlinearSolve/g0Xmj/src/OrdinaryDiffEqNonlinearSolve.jl:1
in expression starting at stdin:5
              ✗ OrdinaryDiffEqNonlinearSolve
ERROR: LoadError: Precompiled image Base.PkgId(Base.UUID("4302a76b-040a-498a-8c04-15b101fed76b"), "OrdinaryDiffEqDifferentiation") not available with flags CacheFlags(; use_pkgimages=false, debug_level=1, check_bounds=1, inline=true, opt_level=0)
Stacktrace:
  [1] error(s::String)
    @ Base ./error.jl:56
  [2] __require_prelocked(pkg::Base.PkgId, env::String)
    @ Base ./loading.jl:2818
  [3] _require_prelocked(uuidkey::Base.PkgId, env::String)
    @ Base ./loading.jl:2672
  [4] macro expansion
    @ ./loading.jl:2599 [inlined]
  [5] String(s::Symbol)
    @ Base ./lock.jl:376 [inlined]
  [6] __require(into::Module, mod::Symbol)
    @ Base ./loading.jl:2563
  [7] require(into::Module, mod::Symbol)
    @ Base ./loading.jl:2539 [inlined]
  [8] eval_import_path(at::Module, from::Nothing, path::Expr, keyword::String)
    @ Base ./module.jl:36 [inlined]
  [9] eval_import_path_all(at::Module, path::Expr, keyword::String)
    @ Base ./module.jl:60
 [10] _eval_import(::Bool, ::Module, ::Expr, ::Expr, ::Vararg{Expr})
    @ Base ./module.jl:101
 [11] top-level scope
    @ ~/.julia/packages/OrdinaryDiffEqSDIRK/exKyM/src/OrdinaryDiffEqSDIRK.jl:23
 [12] include(mod::Module, _path::String)
    @ Base ./Base.jl:326
 [13] include_package_for_output(pkg::Base.PkgId, input::String, syntax_version::VersionNumber, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)
    @ Base ./loading.jl:3271
 [14] top-level scope
    @ stdin:5
 [15] eval(m::Module, e::Any)
    @ Core ./boot.jl:517
 [16] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
    @ Base ./loading.jl:3113
 [17] materialize(bc::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, Type{Symbol}, Tuple{Vector{SubString{String}}}})
    @ Base.Broadcast ./loading.jl:3123 [inlined]
 [18] exec_options(opts::Base.JLOptions)
    @ Base ./client.jl:350
 [19] _start()
    @ Base ./client.jl:593
in expression starting at /home/pkgeval/.julia/packages/OrdinaryDiffEqSDIRK/exKyM/src/OrdinaryDiffEqSDIRK.jl:1
in expression starting at stdin:5
              ✗ OrdinaryDiffEqSDIRK
ERROR: LoadError: Precompiled image Base.PkgId(Base.UUID("2d112036-d095-4a1e-ab9a-08536f3ecdbf"), "OrdinaryDiffEqSDIRK") not available with flags CacheFlags(; use_pkgimages=false, debug_level=1, check_bounds=1, inline=true, opt_level=0)
Stacktrace:
  [1] error(s::String)
    @ Base ./error.jl:56
  [2] __require_prelocked(pkg::Base.PkgId, env::String)
    @ Base ./loading.jl:2818
  [3] _require_prelocked(uuidkey::Base.PkgId, env::String)
    @ Base ./loading.jl:2672
  [4] macro expansion
    @ ./loading.jl:2599 [inlined]
  [5] String(s::Symbol)
    @ Base ./lock.jl:376 [inlined]
  [6] __require(into::Module, mod::Symbol)
    @ Base ./loading.jl:2563
  [7] require(into::Module, mod::Symbol)
    @ Base ./loading.jl:2539 [inlined]
  [8] eval_import_path(at::Module, from::Nothing, path::Expr, keyword::String)
    @ Base ./module.jl:36 [inlined]
  [9] eval_import_path_all(at::Module, path::Expr, keyword::String)
    @ Base ./module.jl:60
 [10] _eval_import(::Bool, ::Module, ::Expr, ::Expr, ::Vararg{Expr})
    @ Base ./module.jl:101
 [11] top-level scope
    @ ~/.julia/packages/OrdinaryDiffEqBDF/YNbbA/src/OrdinaryDiffEqBDF.jl:26
 [12] include(mod::Module, _path::String)
    @ Base ./Base.jl:326
 [13] include_package_for_output(pkg::Base.PkgId, input::String, syntax_version::VersionNumber, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)
    @ Base ./loading.jl:3271
 [14] top-level scope
    @ stdin:5
 [15] eval(m::Module, e::Any)
    @ Core ./boot.jl:517
 [16] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
    @ Base ./loading.jl:3113
 [17] materialize(bc::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, Type{Symbol}, Tuple{Vector{SubString{String}}}})
    @ Base.Broadcast ./loading.jl:3123 [inlined]
 [18] exec_options(opts::Base.JLOptions)
    @ Base ./client.jl:350
 [19] _start()
    @ Base ./client.jl:593
in expression starting at /home/pkgeval/.julia/packages/OrdinaryDiffEqBDF/YNbbA/src/OrdinaryDiffEqBDF.jl:1
in expression starting at stdin:5
              ✗ OrdinaryDiffEqBDF
ERROR: LoadError: Precompiled image Base.PkgId(Base.UUID("43230ef6-c299-4910-a778-202eb28ce4ce"), "OrdinaryDiffEqRosenbrock") not available with flags CacheFlags(; use_pkgimages=false, debug_level=1, check_bounds=1, inline=true, opt_level=0)
Stacktrace:
  [1] error(s::String)
    @ Base ./error.jl:56
  [2] __require_prelocked(pkg::Base.PkgId, env::String)
    @ Base ./loading.jl:2818
  [3] _require_prelocked(uuidkey::Base.PkgId, env::String)
    @ Base ./loading.jl:2672
  [4] macro expansion
    @ ./loading.jl:2599 [inlined]
  [5] String(s::Symbol)
    @ Base ./lock.jl:376 [inlined]
  [6] __require(into::Module, mod::Symbol)
    @ Base ./loading.jl:2563
  [7] require(into::Module, mod::Symbol)
    @ Base ./loading.jl:2539 [inlined]
  [8] eval_import_path(at::Module, from::Nothing, path::Expr, keyword::String)
    @ Base ./module.jl:36 [inlined]
  [9] eval_import_path_all(at::Module, path::Expr, keyword::String)
    @ Base ./module.jl:60
 [10] _eval_import(::Bool, ::Module, ::Expr, ::Expr, ::Vararg{Expr})
    @ Base ./module.jl:101
 [11] top-level scope
    @ ~/.julia/packages/OrdinaryDiffEqDefault/zk8rY/src/OrdinaryDiffEqDefault.jl:9
 [12] include(mod::Module, _path::String)
    @ Base ./Base.jl:326
 [13] include_package_for_output(pkg::Base.PkgId, input::String, syntax_version::VersionNumber, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)
    @ Base ./loading.jl:3271
 [14] top-level scope
    @ stdin:5
 [15] eval(m::Module, e::Any)
    @ Core ./boot.jl:517
 [16] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
    @ Base ./loading.jl:3113
 [17] materialize(bc::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, Type{Symbol}, Tuple{Vector{SubString{String}}}})
    @ Base.Broadcast ./loading.jl:3123 [inlined]
 [18] exec_options(opts::Base.JLOptions)
    @ Base ./client.jl:350
 [19] _start()
    @ Base ./client.jl:593
in expression starting at /home/pkgeval/.julia/packages/OrdinaryDiffEqDefault/zk8rY/src/OrdinaryDiffEqDefault.jl:1
in expression starting at stdin:5
              ✗ OrdinaryDiffEqDefault
ERROR: LoadError: Precompiled image Base.PkgId(Base.UUID("43230ef6-c299-4910-a778-202eb28ce4ce"), "OrdinaryDiffEqRosenbrock") not available with flags CacheFlags(; use_pkgimages=false, debug_level=1, check_bounds=1, inline=true, opt_level=0)
Stacktrace:
  [1] error(s::String)
    @ Base ./error.jl:56
  [2] __require_prelocked(pkg::Base.PkgId, env::String)
    @ Base ./loading.jl:2818
  [3] _require_prelocked(uuidkey::Base.PkgId, env::String)
    @ Base ./loading.jl:2672
  [4] macro expansion
    @ ./loading.jl:2599 [inlined]
  [5] String(s::Symbol)
    @ Base ./lock.jl:376 [inlined]
  [6] __require(into::Module, mod::Symbol)
    @ Base ./loading.jl:2563
  [7] require(into::Module, mod::Symbol)
    @ Base ./loading.jl:2539 [inlined]
  [8] eval_import_path(at::Module, from::Nothing, path::Expr, keyword::String)
    @ Base ./module.jl:36 [inlined]
  [9] eval_import_path_all(at::Module, path::Expr, keyword::String)
    @ Base ./module.jl:60
 [10] _eval_import(::Bool, ::Module, ::Expr, ::Expr, ::Vararg{Expr})
    @ Base ./module.jl:101
 [11] top-level scope
    @ ~/.julia/packages/OrdinaryDiffEq/X8TsL/src/OrdinaryDiffEq.jl:14
 [12] include(mod::Module, _path::String)
    @ Base ./Base.jl:326
 [13] include_package_for_output(pkg::Base.PkgId, input::String, syntax_version::VersionNumber, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)
    @ Base ./loading.jl:3271
 [14] top-level scope
    @ stdin:5
 [15] eval(m::Module, e::Any)
    @ Core ./boot.jl:517
 [16] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
    @ Base ./loading.jl:3113
 [17] materialize(bc::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, Type{Symbol}, Tuple{Vector{SubString{String}}}})
    @ Base.Broadcast ./loading.jl:3123 [inlined]
 [18] exec_options(opts::Base.JLOptions)
    @ Base ./client.jl:350
 [19] _start()
    @ Base ./client.jl:593
in expression starting at /home/pkgeval/.julia/packages/OrdinaryDiffEq/X8TsL/src/OrdinaryDiffEq.jl:1
in expression starting at stdin:5
              ✗ OrdinaryDiffEq
  37 dependencies successfully precompiled in 572 seconds. 163 already precompiled.

Precompilation completed after 594.34s


################################################################################
# Testing
#

     Testing LabelledArrays
      Status `/tmp/jl_KZPFf7/Project.toml`
  [9b6a8646] AllocCheck v0.2.3
  [4fba245c] ArrayInterface v7.24.0
  [d360d2e6] ChainRulesCore v1.26.1
  [cdddcdb0] ChainRulesTestUtils v1.13.1
  [f6369f11] ForwardDiff v1.3.3
  [2ee39098] LabelledArrays v1.19.0
  [1914dd2f] MacroTools v0.5.16
  [1dea7af3] OrdinaryDiffEq v7.0.0
  [d236fae5] PreallocationTools v1.2.0
  [aea7be01] PrecompileTools v1.3.3
  [731186ca] RecursiveArrayTools v4.3.0
  [90137ffa] StaticArrays v1.9.18
  [b77e0a4c] InteractiveUtils v1.11.0
  [37e2e46d] LinearAlgebra v1.13.0
  [8dfed614] Test v1.11.0
      Status `/tmp/jl_KZPFf7/Manifest.toml`
  [47edcb42] ADTypes v1.22.0
  [7d9f7c33] Accessors v0.1.44
  [79e6a3ab] Adapt v4.5.2
  [9b6a8646] AllocCheck v0.2.3
  [4fba245c] ArrayInterface v7.24.0
  [70df07ce] BracketingNonlinearSolve v1.12.1
  [fa961155] CEnum v0.5.0
  [d360d2e6] ChainRulesCore v1.26.1
  [cdddcdb0] ChainRulesTestUtils v1.13.1
  [38540f10] CommonSolve v0.2.6
  [bbf7d656] CommonSubexpressions v0.3.1
  [34da2185] Compat v4.18.1
  [a33af91c] CompositionsBase v0.1.2
  [2569d6c7] ConcreteStructs v0.2.3
  [187b0558] ConstructionBase v1.6.0
  [864edb3b] DataStructures v0.19.4
  [2b5f629d] DiffEqBase v7.2.1
  [163ba53b] DiffResults v1.1.0
  [b552c78f] DiffRules v1.15.1
  [a0c0ee7d] DifferentiationInterface v0.7.17
  [ffbed154] DocStringExtensions v0.9.5
  [4e289a0a] EnumX v1.0.7
  [f151be2c] EnzymeCore v0.8.20
  [e2ba6199] ExprTools v0.1.10
  [7034ab61] FastBroadcast v1.3.2
  [9aa1b823] FastClosures v0.3.2
  [a4df4552] FastPower v1.3.1
  [6a86dc24] FiniteDiff v2.31.0
  [26cc04aa] FiniteDifferences v0.12.33
  [f6369f11] ForwardDiff v1.3.3
  [069b7b12] FunctionWrappers v1.1.3
  [77dc65aa] FunctionWrappersWrappers v1.8.0
  [46192b85] GPUArraysCore v0.2.0
  [61eb1bfa] GPUCompiler v1.10.0
  [3587e190] InverseFunctions v0.1.17
  [92d709cd] IrrationalConstants v0.2.6
  [82899510] IteratorInterfaceExtensions v1.0.0
  [692b3bcd] JLLWrappers v1.7.1
  [ba0b0d4f] Krylov v0.10.6
  [929cbde3] LLVM v9.7.1
  [2ee39098] LabelledArrays v1.19.0
  [87fe0de2] LineSearch v0.1.9
  [7ed4a6bd] LinearSolve v3.75.0
  [2ab3a3ac] LogExpFunctions v0.3.29
  [e6f89c97] LoggingExtras v1.2.0
  [1914dd2f] MacroTools v0.5.16
  [bb5d69b7] MaybeInplace v0.1.4
  [46d2c3a1] MuladdMacro v0.2.4
  [77ba4419] NaNMath v1.1.3
  [8913a72c] NonlinearSolve v4.19.0
  [be0214bd] NonlinearSolveBase v2.25.0
  [5959db7a] NonlinearSolveFirstOrder v2.1.1
  [9a2c21bd] NonlinearSolveQuasiNewton v1.13.1
  [26075421] NonlinearSolveSpectralMethods v1.7.1
  [bac558e1] OrderedCollections v1.8.1
  [1dea7af3] OrdinaryDiffEq v7.0.0
  [6ad6398a] OrdinaryDiffEqBDF v2.0.0
  [bbf590c4] OrdinaryDiffEqCore v4.0.0
  [50262376] OrdinaryDiffEqDefault v2.1.0
  [4302a76b] OrdinaryDiffEqDifferentiation v3.0.0
  [127b3ac7] OrdinaryDiffEqNonlinearSolve v2.0.0
  [43230ef6] OrdinaryDiffEqRosenbrock v2.0.0
  [b4bd8bb3] OrdinaryDiffEqRosenbrockTableaus v2.0.0
  [2d112036] OrdinaryDiffEqSDIRK v2.0.0
  [b1df2697] OrdinaryDiffEqTsit5 v2.0.0
  [79d7bb75] OrdinaryDiffEqVerner v2.0.0
  [d236fae5] PreallocationTools v1.2.0
  [aea7be01] PrecompileTools v1.3.3
  [21216c6a] Preferences v1.5.2
  [3cdcf5f2] RecipesBase v1.3.4
  [731186ca] RecursiveArrayTools v4.3.0
  [189a3867] Reexport v1.2.2
  [ae029012] Requires v1.3.1
  [708f8203] Richardson v1.4.2
  [7e49a35a] RuntimeGeneratedFunctions v0.5.18
  [0bca4576] SciMLBase v3.7.1
  [19f34311] SciMLJacobianOperators v0.1.13
⌅ [a6db7da4] SciMLLogging v1.9.1
  [c0aeaf25] SciMLOperators v1.18.0
  [431bcebd] SciMLPublic v1.0.1
  [53ae85a6] SciMLStructures v1.10.0
  [6c6a2e73] Scratch v1.3.0
  [efcf1570] Setfield v1.1.2
  [727e6d20] SimpleNonlinearSolve v2.11.1
  [0a514795] SparseMatrixColorings v0.4.27
  [276daf66] SpecialFunctions v2.7.2
  [90137ffa] StaticArrays v1.9.18
  [1e83bf80] StaticArraysCore v1.4.4
  [10745b16] Statistics v1.11.1
  [fd094767] Suppressor v0.2.8
  [2efcf032] SymbolicIndexingInterface v0.3.47
  [a759f4b9] TimerOutputs v0.5.29
  [e689c965] Tracy v0.1.6
  [781d530d] TruncatedStacktraces v1.4.0
  [1d5cc7b8] IntelOpenMP_jll v2025.2.0+0
  [dad2f222] LLVMExtra_jll v0.0.42+0
  [ad6e5548] LibTracyClient_jll v0.13.1+0
  [856f044c] MKL_jll v2025.2.0+0
  [efe28fd5] OpenSpecFun_jll v0.5.6+0
  [1317d2d5] oneTBB_jll v2022.0.0+1
  [0dad84c5] ArgTools v1.1.2
  [56f22d72] Artifacts v1.11.0
  [2a0f44e3] Base64 v1.11.0
  [ade2ca70] Dates v1.11.0
  [8ba89e20] Distributed v1.11.0
  [f43a241f] Downloads v1.7.0
  [7b1f6079] FileWatching v1.11.0
  [9fa8497b] Future v1.11.0
  [b77e0a4c] InteractiveUtils v1.11.0
  [ac6e5ff7] JuliaSyntaxHighlighting v1.13.0
  [4af54fe1] LazyArtifacts v1.11.0
  [b27032c2] LibCURL v1.0.0
  [76f85450] LibGit2 v1.11.0
  [8f399da3] Libdl v1.11.0
  [37e2e46d] LinearAlgebra v1.13.0
  [56ddb016] Logging v1.11.0
  [d6f4376e] Markdown v1.11.0
  [ca575930] NetworkOptions v1.3.0
  [44cfe95a] Pkg v1.14.0
  [de0858da] Printf v1.11.0
  [9a3f8284] Random v1.11.0
  [ea8e919c] SHA v1.0.0
  [9e88b42a] Serialization v1.11.0
  [6462fe0b] Sockets v1.11.0
  [2f01184e] SparseArrays v1.13.0
  [f489334b] StyledStrings v1.13.0
  [fa267f1f] TOML v1.0.3
  [a4e569a6] Tar v1.10.0
  [8dfed614] Test v1.11.0
  [cf7118a7] UUIDs v1.11.0
  [4ec0a83e] Unicode v1.11.0
  [e66e0078] CompilerSupportLibraries_jll v1.5.1+0
  [deac9b47] LibCURL_jll v8.19.0+0
  [e37daf67] LibGit2_jll v1.9.2+0
  [29816b5a] LibSSH2_jll v1.11.3+1
  [14a3606d] MozillaCACerts_jll v2026.3.19
  [4536629a] OpenBLAS_jll v0.3.33+0
  [05823500] OpenLibm_jll v0.8.7+0
  [458c3c95] OpenSSL_jll v3.5.6+0
  [efcefdf7] PCRE2_jll v10.47.0+0
  [bea87d4a] SuiteSparse_jll v7.10.1+0
  [83775a58] Zlib_jll v1.3.2+0
  [3161d3a3] Zstd_jll v1.5.7+1
  [8e850b90] libblastrampoline_jll v5.15.0+0
  [8e850ede] nghttp2_jll v1.69.0+0
  [3f19e933] p7zip_jll v17.8.0+0
        Info Packages marked with ⌅ have new versions available but compatibility constraints restrict them from upgrading.
     Testing Running tests...
┌ Warning: inference tests have been disabled
└ @ ChainRulesTestUtils ~/.julia/packages/ChainRulesTestUtils/RZidV/src/global_config.jl:13
3-element SLArray{Tuple{3}, Int64, 1, 3, (:a, :b, :c)} with indices SOneTo(3):
 :a => 1
 :b => 2
 :c => 3
3-element SLArray{Tuple{3}, Float64, 1, 3, (a = 1:2, b = 3)} with indices SOneTo(3):
 :a => 1.0
 :a => 2.0
 :b => 3.0
3-element SLArray{Tuple{3}, Float64, 1, 3, (a = 1:2, b = 2:3)} with indices SOneTo(3):
 :a => 1.0
 :a => 2.0
 :b => 3.0
2-element SLArray{Tuple{2}, Int64, 1, 2, (a = 1, b = 2)} with indices SOneTo(2):
 :a => 1
 :b => 2
2×2 SLArray{Tuple{2, 2}, Int64, 2, 4, (a = (2, Colon()), b = 3)} with indices SOneTo(2)×SOneTo(2):
 nothing => 1  :b => 3
      :a => 2  :a => 4
Test Summary: | Pass  Total   Time
SLArrays      |   48     48  15.6s
 16.098831 seconds (8.38 M allocations: 477.559 MiB, 2.86% gc time, 98.38% compilation time: 20% of which was recompilation)
3-element LArray{Float64, 1, Vector{Float64}, (:a, :b, :c)}:
 :a => 1.0
 :b => 2.0
 :c => 3.0
(i, s) = (1, :a)
(i, s) = (2, :b)
(i, s) = (3, :c)
  0.014883 seconds (2.53 k allocations: 136.484 KiB, 99.70% compilation time)
  0.000011 seconds (9 allocations: 448 bytes)
  0.015517 seconds (3.61 k allocations: 203.250 KiB, 99.76% compilation time)
  0.000004 seconds (9 allocations: 448 bytes)
MethodInstance for (::var"#g#g##1")(::LArray{Float64, 1, Vector{Float64}, (:a, :b, :c)})
  from (::var"#g#g##1")(x) @ Main ~/.julia/packages/LabelledArrays/S1mXJ/test/larrays.jl:31
Arguments
  #self#::Core.Const(var"#g#g##1"())
  x::LArray{Float64, 1, Vector{Float64}, (:a, :b, :c)}
Body::Float64
1 ─ %1 = Base.getproperty(x, :a)::Float64
└──      return %1

MethodInstance for Core.kwcall(::@NamedTuple{a::Int64, b::Int64, c::Int64, d::Int64}, ::Type{LArray}, ::Tuple{Int64, Int64})
  from kwcall(::NamedTuple, ::Type{LArray}, size::NTuple{S, Int64}) where S @ LabelledArrays ~/.julia/packages/LabelledArrays/S1mXJ/src/larray.jl:48
Static Parameters
  S = 2
Arguments
  _::Core.Const(Core.kwcall)
  @_2::@NamedTuple{a::Int64, b::Int64, c::Int64, d::Int64}
  @_3::Type{LArray}
  size::Tuple{Int64, Int64}
Locals
  kwargs...::Base.Pairs{Symbol, Int64, Nothing, @NamedTuple{a::Int64, b::Int64, c::Int64, d::Int64}}
Body::LArray{Int64, 2, Matrix{Int64}, (:a, :b, :c, :d)}
1 ─      (kwargs... = Base.pairs(@_2))
│   %2 = LabelledArrays.:(var"#LArray#9")::Core.Const(LabelledArrays.var"#LArray#9")
│   %3 = kwargs...::Base.Pairs{Symbol, Int64, Nothing, @NamedTuple{a::Int64, b::Int64, c::Int64, d::Int64}}
│   %4 = (%2)(%3, @_3, size)::LArray{Int64, 2, Matrix{Int64}, (:a, :b, :c, :d)}
└──      return %4

MethodInstance for convert(::Type{NamedTuple}, ::LArray{Int64, 2, Matrix{Int64}, (:a, :b, :c, :d)})
  from convert(::Type{NamedTuple}, x::LArray{T, N, D, Syms}) where {T, N, D, Syms} @ LabelledArrays ~/.julia/packages/LabelledArrays/S1mXJ/src/larray.jl:16
Static Parameters
  T = Int64
  N = 2
  D = Matrix{Int64}
  Syms = (:a, :b, :c, :d)
Arguments
  #self#::Core.Const(convert)
  _::Type{NamedTuple}
  x::LArray{Int64, 2, Matrix{Int64}, (:a, :b, :c, :d)}
Locals
  tup::NTuple{4, Int64}
Body::@NamedTuple{a::Int64, b::Int64, c::Int64, d::Int64}
1 ─ %1  = LabelledArrays.NTuple::Core.Const(NTuple{N, T} where {N, T})
│   %2  = LabelledArrays.length::Core.Const(length)
│   %3  = $(Expr(:static_parameter, 4))::Core.Const((:a, :b, :c, :d))
│   %4  = (%2)(%3)::Core.Const(4)
│   %5  = $(Expr(:static_parameter, 1))::Core.Const(Int64)
│   %6  = Core.apply_type(%1, %4, %5)::Core.Const(NTuple{4, Int64})
│         (tup = (%6)(x))
│   %8  = LabelledArrays.NamedTuple::Core.Const(NamedTuple)
│   %9  = $(Expr(:static_parameter, 4))::Core.Const((:a, :b, :c, :d))
│   %10 = LabelledArrays.typeof::Core.Const(typeof)
│   %11 = tup::NTuple{4, Int64}
│   %12 = (%10)(%11)::Core.Const(NTuple{4, Int64})
│   %13 = Core.apply_type(%8, %9, %12)::Core.Const(@NamedTuple{a::Int64, b::Int64, c::Int64, d::Int64})
│   %14 = tup::NTuple{4, Int64}
│   %15 = (%13)(%14)::@NamedTuple{a::Int64, b::Int64, c::Int64, d::Int64}
└──       return %15

MethodInstance for collect(::Base.Generator{UnitRange{Int64}, LabelledArrays.var"#12#13"{(:a, :b, :c, :d), LArray{Int64, 2, Matrix{Int64}, (:a, :b, :c, :d)}}})
  from collect(itr::Base.Generator) @ Base array.jl:826
Arguments
  #self#::Core.Const(collect)
  itr::Base.Generator{UnitRange{Int64}, LabelledArrays.var"#12#13"{(:a, :b, :c, :d), LArray{Int64, 2, Matrix{Int64}, (:a, :b, :c, :d)}}}
Locals
  @_3::Int64
  RT::Type{AbstractVector{<:Pair{Symbol, Int64}}}
  et′::Type{Pair{Symbol, Int64}}
  dest::Vector{Pair{Symbol, Int64}}
  st::Int64
  v1::Pair{Symbol, Int64}
  y::UNION{NOTHING, TUPLE{PAIR{SYMBOL, INT64}, INT64}}
  shp::Tuple{Base.OneTo{Int64}}
  et::Type{Pair{Symbol, Int64}}
  T::Type{Pair{Symbol, Int64}}
  isz::Base.HasShape{1}
  @_14::TypeVar
  @_15::Type{Pair{Symbol, Int64}}
  @_16::Type{AbstractVector{<:Pair{Symbol, Int64}}}
Body::Vector{Pair{Symbol, Int64}}
1 ──        Core.NewvarNode(:(@_3))
│           Core.NewvarNode(:(RT))
│           Core.NewvarNode(:(et′))
│           Core.NewvarNode(:(dest))
│           Core.NewvarNode(:(st))
│           Core.NewvarNode(:(v1))
│           Core.NewvarNode(:(y))
│           Core.NewvarNode(:(shp))
│           Core.NewvarNode(:(et))
│           Core.NewvarNode(:(T))
│    %11  = Base.IteratorSize::Core.Const(Base.IteratorSize)
│    %12  = Base.getproperty(itr, :iter)::UnitRange{Int64}
│           (isz = (%11)(%12))
│    %14  = Base.isa::Core.Const(isa)
│    %15  = Base.Generator::Core.Const(Base.Generator)
│    %16  = (%14)(itr, %15)::Core.Const(true)
└───        goto #4 if not %16
2 ── %18  = Base.isa::Core.Const(isa)
│    %19  = Base.getproperty(itr, :f)::LabelledArrays.var"#12#13"{(:a, :b, :c, :d), LArray{Int64, 2, Matrix{Int64}, (:a, :b, :c, :d)}}
│    %20  = Base.Type::Core.Const(Type)
│    %21  = (%18)(%19, %20)::Core.Const(false)
└───        goto #4 if not %21
3 ──        Core.Const(:(T = Base.getproperty(itr, :f)))
└───        Core.Const(:(goto %33))
4 ┄─ %25  = Base.Base::Core.Const(Base)
│    %26  = Base.getproperty(%25, :_return_type)::Core.Const(Compiler.return_type)
│    %27  = Base._iterator_upper_bound::Core.Const(Base._iterator_upper_bound)
│    %28  = Base.Tuple::Core.Const(Tuple)
│    %29  = Base.typeof::Core.Const(typeof)
│    %30  = (%29)(itr)::Core.Const(Base.Generator{UnitRange{Int64}, LabelledArrays.var"#12#13"{(:a, :b, :c, :d), LArray{Int64, 2, Matrix{Int64}, (:a, :b, :c, :d)}}})
│    %31  = Core.apply_type(%28, %30)::Core.Const(Tuple{Base.Generator{UnitRange{Int64}, LabelledArrays.var"#12#13"{(:a, :b, :c, :d), LArray{Int64, 2, Matrix{Int64}, (:a, :b, :c, :d)}}}})
│           (T = (%26)(%27, %31))
│    %33  = Base.promote_typejoin_union::Core.Const(Base.promote_typejoin_union)
│    %34  = T::Core.Const(Pair{Symbol, Int64})
│           (et = (%33)(%34))
│    %36  = Base.isa::Core.Const(isa)
│    %37  = isz::Core.Const(Base.HasShape{1}())
│    %38  = Base.SizeUnknown::Core.Const(Base.SizeUnknown)
│    %39  = (%36)(%37, %38)::Core.Const(false)
└───        goto #6 if not %39
5 ──        Core.Const(:(Base.grow_to!))
│           Core.Const(:(Base.Vector))
│           Core.Const(:(et))
│           Core.Const(:(Core.apply_type(%42, %43)))
│           Core.Const(:((%44)()))
│           Core.Const(:((%41)(%45, itr)))
└───        Core.Const(:(return %46))
6 ┄─ %48  = Base._similar_shape::Core.Const(Base._similar_shape)
│    %49  = isz::Core.Const(Base.HasShape{1}())
│           (shp = (%48)(itr, %49))
│    %51  = Base.iterate::Core.Const(iterate)
│           (y = (%51)(itr))
│    %53  = Base.:(===)::Core.Const(===)
│    %54  = y::UNION{NOTHING, TUPLE{PAIR{SYMBOL, INT64}, INT64}}
│    %55  = Base.nothing::Core.Const(nothing)
│    %56  = (%53)(%54, %55)::Bool
└───        goto #8 if not %56
7 ── %58  = Base._array_for_inner::Core.Const(Base._array_for_inner)
│    %59  = et::Core.Const(Pair{Symbol, Int64})
│    %60  = isz::Core.Const(Base.HasShape{1}())
│    %61  = shp::Tuple{Base.OneTo{Int64}}
│    %62  = (%58)(%59, %60, %61)::Vector{Pair{Symbol, Int64}}
└───        return %62
8 ── %64  = y::Tuple{Pair{Symbol, Int64}, Int64}
│    %65  = Base.indexed_iterate(%64, 1)::Core.PartialStruct(Tuple{Pair{Symbol, Int64}, Int64}, Union{Nothing, Bool}[0, 0], Any[Pair{Symbol, Int64}, Core.Const(2)])
│           (v1 = Core.getfield(%65, 1))
│           (@_3 = Core.getfield(%65, 2))
│    %68  = y::Tuple{Pair{Symbol, Int64}, Int64}
│    %69  = @_3::Core.Const(2)
│    %70  = Base.indexed_iterate(%68, 2, %69)::Core.PartialStruct(Tuple{Int64, Int64}, Union{Nothing, Bool}[0, 0], Any[Int64, Core.Const(3)])
│           (st = Core.getfield(%70, 1))
│    %72  = Base._array_for_inner::Core.Const(Base._array_for_inner)
│    %73  = Base.typeof::Core.Const(typeof)
│    %74  = v1::Pair{Symbol, Int64}
│    %75  = (%73)(%74)::Core.Const(Pair{Symbol, Int64})
│    %76  = isz::Core.Const(Base.HasShape{1}())
│    %77  = shp::Tuple{Base.OneTo{Int64}}
│           (dest = (%72)(%75, %76, %77))
│    %79  = Base.:<:::Core.Const(<:)
│    %80  = et::Core.Const(Pair{Symbol, Int64})
│    %81  = Base.Type::Core.Const(Type)
│    %82  = (%79)(%80, %81)::Core.Const(false)
└───        goto #10 if not %82
9 ──        Core.Const(:(@_15 = Base.Type))
└───        Core.Const(:(goto %88))
10 ┄ %86  = et::Core.Const(Pair{Symbol, Int64})
│           (@_15 = %86)
│    %88  = @_15::Core.Const(Pair{Symbol, Int64})
│           (et′ = %88)
│    %90  = Base.isa::Core.Const(isa)
│    %91  = dest::Vector{Pair{Symbol, Int64}}
│    %92  = Base.AbstractArray::Core.Const(AbstractArray)
│    %93  = (%90)(%91, %92)::Core.Const(true)
└───        goto #12 if not %93
11 ─ %95  = et′::Core.Const(Pair{Symbol, Int64})
│    %96  = Core.TypeVar(Symbol("#s217"), %95)::Compiler.PartialTypeVar(var"#s217"<:Pair{Symbol, Int64}, true, true)
│           (@_14 = %96)
│    %98  = @_14::Compiler.PartialTypeVar(var"#s217"<:Pair{Symbol, Int64}, true, true)
│    %99  = Base.AbstractArray::Core.Const(AbstractArray)
│    %100 = @_14::Compiler.PartialTypeVar(var"#s217"<:Pair{Symbol, Int64}, true, true)
│    %101 = Base.ndims::Core.Const(ndims)
│    %102 = dest::Vector{Pair{Symbol, Int64}}
│    %103 = (%101)(%102)::Core.Const(1)
│    %104 = Core.apply_type(%99, %100, %103)::TYPE{ABSTRACTARRAY{VAR"#S217"<:PAIR{SYMBOL, INT64}, 1}}
│           (@_16 = Core.UnionAll(%98, %104))
└───        goto #13
12 ─        Core.Const(:(@_16 = Base.Any))
13 ┄ %108 = @_16::Type{AbstractVector{<:Pair{Symbol, Int64}}}
│           (RT = %108)
│    %110 = Base.collect_to_with_first!::Core.Const(Base.collect_to_with_first!)
│    %111 = dest::Vector{Pair{Symbol, Int64}}
│    %112 = v1::Pair{Symbol, Int64}
│    %113 = st::Int64
│    %114 = (%110)(%111, %112, itr, %113)::Vector{Pair{Symbol, Int64}}
│    %115 = RT::Type{AbstractVector{<:Pair{Symbol, Int64}}}
│    %116 = Core.typeassert(%114, %115)::Vector{Pair{Symbol, Int64}}
└───        return %116

2×2 LArray{Float64, 2, Matrix{Float64}, (:a, :b, :c, :d)}:
 :a => 6.7787334273226e-310   :c => 6.778749028307e-310
 :b => 6.77873342732417e-310  :d => 9.4e-323
3-element LArray{Float64, 1, Vector{Float64}, (a = 1:2, b = 3)}:
 :a => 1.0
 :a => 2.0
 :b => 3.0
2-element LArray{Float64, 1, Vector{Float64}, (a = 1, b = 2)}:
 :a => 1.0
 :b => 2.0
2×2 LArray{Int64, 2, Matrix{Int64}, (a = (2, Colon()), b = 2:3)}:
 nothing => 1  :b => 2
      :a => 3  :a => 4
┌ Warning: The supplied DiffCache was too small and was enlarged. This incurs allocations
│         on the first call to `get_tmp`. If few calls to `get_tmp` occur and optimal performance is essential,
│         consider changing 'N'/chunk size of this DiffCache to 3.
└ @ PreallocationTools ~/.julia/packages/PreallocationTools/K2Foo/src/PreallocationTools.jl:204
Test Summary: | Pass  Broken  Total     Time
LArrays       |   72       4     76  1m08.4s
 68.390619 seconds (21.02 M allocations: 1.275 GiB, 1.74% gc time, 99.11% compilation time: 45% of which was recompilation)

DiffEq: Error During Test at /home/pkgeval/.julia/packages/LabelledArrays/S1mXJ/test/diffeq.jl:18
  Test threw exception
  Expression: sol.retcode == SciMLBase.ReturnCode.Success
  UndefVarError: `SciMLBase` not defined in `Main`
  Suggestion: check for spelling errors or missing imports.
  Hint: SciMLBase is loaded but not imported in the active module Main.
  Hint: a global variable of this name also exists in SciMLBase.
      - Also exported by BracketingNonlinearSolve (loaded but not imported in Main).
      - Also exported by DiffEqBase (loaded but not imported in Main).
      - Also exported by OrdinaryDiffEqCore (loaded but not imported in Main).
      - Also exported by OrdinaryDiffEqTsit5 (loaded but not imported in Main).
      - Also exported by OrdinaryDiffEqVerner (loaded but not imported in Main).
      - Also exported by LinearSolve (loaded but not imported in Main).
      - Also exported by OrdinaryDiffEqRosenbrock (loaded but not imported in Main).
      - Also exported by SimpleNonlinearSolve (loaded but not imported in Main).
      - Also exported by NonlinearSolveFirstOrder (loaded but not imported in Main).
      - Also exported by NonlinearSolveQuasiNewton (loaded but not imported in Main).
      - Also exported by NonlinearSolveSpectralMethods (loaded but not imported in Main).
      - Also exported by NonlinearSolve (loaded but not imported in Main).
      - Also exported by OrdinaryDiffEqSDIRK (loaded but not imported in Main).
      - Also exported by OrdinaryDiffEqBDF (loaded but not imported in Main).
      - Also exported by OrdinaryDiffEqDefault (loaded but not imported in Main).
  Stacktrace:
    [1] top-level scope
      @ ~/.julia/packages/LabelledArrays/S1mXJ/test/diffeq.jl:560
    [2] macro expansion
      @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]
    [3] include(mapexpr::Function, mod::Module, _path::String)
      @ Base ./Base.jl:327
    [4] macro expansion
      @ ~/.julia/packages/LabelledArrays/S1mXJ/test/runtests.jl:18 [inlined]
    [5] macro expansion
      @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
    [6] macro expansion
      @ ~/.julia/packages/LabelledArrays/S1mXJ/test/runtests.jl:18 [inlined]
    [7] macro expansion
      @ ./timing.jl:739 [inlined]
    [8] macro expansion
      @ ~/.julia/packages/LabelledArrays/S1mXJ/test/runtests.jl:17 [inlined]
    [9] macro expansion
      @ ./timing.jl:739 [inlined]
   [10] top-level scope
      @ ~/.julia/packages/LabelledArrays/S1mXJ/test/runtests.jl:10
   [11] include(mapexpr::Function, mod::Module, _path::String)
      @ Base ./Base.jl:327
   [12] top-level scope
      @ none:6
   [13] eval(m::Module, e::Any)
      @ Core ./boot.jl:517
   [14] exec_options(opts::Base.JLOptions)
      @ Base ./client.jl:318
   [15] _start()
      @ Base ./client.jl:593
Test Summary: | Pass  Error  Total     Time
DiffEq        |    8      1      9  1m59.1s
RNG of the outermost testset: Random.Xoshiro(0x4b4e61d09c7063de, 0xc3955a4e68f39f8a, 0x587f5bee3b647fd2, 0x2e308675b192c4c4, 0x93dee99adb4522f2)
ERROR: LoadError: Some tests did not pass: 8 passed, 0 failed, 1 errored, 0 broken.
in expression starting at /home/pkgeval/.julia/packages/LabelledArrays/S1mXJ/test/runtests.jl:9

Testing failed after 223.5s

ERROR: LoadError: Package LabelledArrays errored during testing
Stacktrace:
  [1] pkgerror(msg::String)
    @ Pkg.Types /opt/julia/share/julia/stdlib/v1.14/Pkg/src/Types.jl:68
  [2] test(ctx::Pkg.Types.Context, pkgs::Vector{PackageSpec}; coverage::Bool, julia_args::Cmd, test_args::Cmd, test_fn::Nothing, force_latest_compatible_version::Bool, allow_earlier_backwards_compatible_versions::Bool, allow_reresolve::Bool)
    @ Pkg.Operations /opt/julia/share/julia/stdlib/v1.14/Pkg/src/Operations.jl:3162
  [3] Cmd(cmd::Cmd)
    @ Base /opt/julia/share/julia/stdlib/v1.14/Pkg/src/Operations.jl:3025 [inlined]
  [4] test(ctx::Pkg.Types.Context, pkgs::Vector{PackageSpec}; coverage::Bool, test_fn::Nothing, julia_args::Cmd, test_args::Cmd, force_latest_compatible_version::Bool, allow_earlier_backwards_compatible_versions::Bool, allow_reresolve::Bool, kwargs::@Kwargs{io::IOContext{IO}})
    @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:586
  [5] test(pkgs::Vector{PackageSpec}; io::IOContext{IO}, kwargs::@Kwargs{julia_args::Cmd})
    @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:172
  [6] test(pkgs::Vector{String}; kwargs::@Kwargs{julia_args::Cmd})
    @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:160
  [7] test
    @ /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:160 [inlined]
  [8] test(pkg::String; kwargs::@Kwargs{julia_args::Cmd})
    @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:159 [inlined]
  [9] top-level scope
    @ /PkgEval.jl/scripts/evaluate.jl:223
 [10] include(mod::Module, _path::String)
    @ Base ./Base.jl:326
 [11] exec_options(opts::Base.JLOptions)
    @ Base ./client.jl:352
 [12] _start()
    @ Base ./client.jl:593
in expression starting at /PkgEval.jl/scripts/evaluate.jl:214

PkgEval failed after 863.15s: package tests unexpectedly errored