Package evaluation of GALAHAD on Julia 1.12.0-rc1.2 (995ff9db19*) started at 2025-07-14T13:32:45.437 ################################################################################ # Set-up # Installing PkgEval dependencies (TestEnv)... Set-up completed after 8.98s ################################################################################ # Installation # Installing GALAHAD... Resolving package versions... Updating `~/.julia/environments/v1.12/Project.toml` [c591611e] + GALAHAD v0.4.2 Updating `~/.julia/environments/v1.12/Manifest.toml` [7d9f7c33] + Accessors v0.1.42 [34da2185] + Compat v4.17.0 [a33af91c] + CompositionsBase v0.1.2 [187b0558] + ConstructionBase v1.6.0 [c591611e] + GALAHAD v0.4.2 [3587e190] + InverseFunctions v0.1.17 [692b3bcd] + JLLWrappers v1.7.0 [1914dd2f] + MacroTools v0.5.16 [21216c6a] + Preferences v1.4.3 [be4d8f0f] + Quadmath v0.5.13 [ae029012] + Requires v1.3.1 [bb5f6f25] + CUTEst_jll v2.5.3+0 [1621ace8] + GALAHAD_jll v5.2.2+0 [017b0a0e] + HSL_jll v4.0.2+0 [e33a78d0] + Hwloc_jll v2.12.1+0 [d00139f3] + METIS_jll v5.1.3+0 [d7ed1dd3] + MUMPS_seq_jll v500.800.0+0 [656ef2d0] + OpenBLAS32_jll v0.3.29+0 [56f22d72] + Artifacts v1.11.0 [ade2ca70] + Dates v1.11.0 [8f399da3] + Libdl v1.11.0 [37e2e46d] + LinearAlgebra v1.12.0 [de0858da] + Printf v1.11.0 [9a3f8284] + Random v1.11.0 [ea8e919c] + SHA v0.7.0 [fa267f1f] + TOML v1.0.3 [cf7118a7] + UUIDs v1.11.0 [4ec0a83e] + Unicode v1.11.0 [e66e0078] + CompilerSupportLibraries_jll v1.3.0+1 [4536629a] + OpenBLAS_jll v0.3.29+0 [8e850b90] + libblastrampoline_jll v5.13.1+0 Installation completed after 4.35s ################################################################################ # Precompilation # Precompiling PkgEval dependencies... Precompiling package dependencies... Precompilation completed after 33.18s ################################################################################ # Testing # Testing GALAHAD Status `/tmp/jl_cj188F/Project.toml` [7d9f7c33] Accessors v0.1.42 [c591611e] GALAHAD v0.4.2 [be4d8f0f] Quadmath v0.5.13 [1621ace8] GALAHAD_jll v5.2.2+0 [656ef2d0] OpenBLAS32_jll v0.3.29+0 [8f399da3] Libdl v1.11.0 [37e2e46d] LinearAlgebra v1.12.0 [de0858da] Printf v1.11.0 [8dfed614] Test v1.11.0 Status `/tmp/jl_cj188F/Manifest.toml` [7d9f7c33] Accessors v0.1.42 [34da2185] Compat v4.17.0 [a33af91c] CompositionsBase v0.1.2 [187b0558] ConstructionBase v1.6.0 [c591611e] GALAHAD v0.4.2 [3587e190] InverseFunctions v0.1.17 [692b3bcd] JLLWrappers v1.7.0 [1914dd2f] MacroTools v0.5.16 [21216c6a] Preferences v1.4.3 [be4d8f0f] Quadmath v0.5.13 [ae029012] Requires v1.3.1 [bb5f6f25] CUTEst_jll v2.5.3+0 [1621ace8] GALAHAD_jll v5.2.2+0 [017b0a0e] HSL_jll v4.0.2+0 [e33a78d0] Hwloc_jll v2.12.1+0 [d00139f3] METIS_jll v5.1.3+0 [d7ed1dd3] MUMPS_seq_jll v500.800.0+0 [656ef2d0] OpenBLAS32_jll v0.3.29+0 [56f22d72] Artifacts v1.11.0 [2a0f44e3] Base64 v1.11.0 [ade2ca70] Dates v1.11.0 [b77e0a4c] InteractiveUtils v1.11.0 [ac6e5ff7] JuliaSyntaxHighlighting v1.12.0 [8f399da3] Libdl v1.11.0 [37e2e46d] LinearAlgebra v1.12.0 [56ddb016] Logging v1.11.0 [d6f4376e] Markdown v1.11.0 [de0858da] Printf v1.11.0 [9a3f8284] Random v1.11.0 [ea8e919c] SHA v0.7.0 [9e88b42a] Serialization v1.11.0 [f489334b] StyledStrings v1.11.0 [fa267f1f] TOML v1.0.3 [8dfed614] Test v1.11.0 [cf7118a7] UUIDs v1.11.0 [4ec0a83e] Unicode v1.11.0 [e66e0078] CompilerSupportLibraries_jll v1.3.0+1 [4536629a] OpenBLAS_jll v0.3.29+0 [8e850b90] libblastrampoline_jll v5.13.1+0 Testing Running tests... [ Info: GALAHAD_INSTALLATION : YGGDRASIL Fortran sparse matrix indexing tests reverse-communication options WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE C: 7 iterations. Optimal objective value = -1.00 status = 0 WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE R: 7 iterations. Optimal objective value = -1.00 status = 0 WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE D: 7 iterations. Optimal objective value = -1.00 status = 0 WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE I: 10 iterations. Optimal objective value = -1.00 status = 0 WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE P: 7 iterations. Optimal objective value = -1.00 status = 0 Test Summary: | Pass Total Time ARC -- Float32 -- Int32 | 1 1 3.4s Fortran sparse matrix indexing tests reverse-communication options WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE C: 7 iterations. Optimal objective value = -1.00 status = 0 WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE R: 7 iterations. Optimal objective value = -1.00 status = 0 WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE D: 7 iterations. Optimal objective value = -1.00 status = 0 WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE I: 10 iterations. Optimal objective value = -1.00 status = 0 WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE P: 7 iterations. Optimal objective value = -1.00 status = 0 Test Summary: | Pass Total Time ARC -- Float32 -- Int64 | 1 1 2.8s Fortran sparse matrix indexing tests reverse-communication options WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE C: 8 iterations. Optimal objective value = -1.00 status = 0 WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE R: 8 iterations. Optimal objective value = -1.00 status = 0 WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE D: 8 iterations. Optimal objective value = -1.00 status = 0 WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE I: 7 iterations. Optimal objective value = -1.00 status = 0 WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE P: 8 iterations. Optimal objective value = -1.00 status = 0 Test Summary: | Pass Total Time ARC -- Float64 -- Int32 | 1 1 3.1s Fortran sparse matrix indexing tests reverse-communication options WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE C: 8 iterations. Optimal objective value = -1.00 status = 0 WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE R: 8 iterations. Optimal objective value = -1.00 status = 0 WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE D: 8 iterations. Optimal objective value = -1.00 status = 0 WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE I: 7 iterations. Optimal objective value = -1.00 status = 0 WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE WARNING: To use the requested linear solver ssids, the environment variables OMP_CANCELLATION and OMP_PROC_BIND must both be set to TRUE P: 8 iterations. Optimal objective value = -1.00 status = 0 Test Summary: | Pass Total Time ARC -- Float64 -- Int64 | 1 1 2.4s Internal error: during type inference of test_arc(Type{Quadmath.Float128}, Type{Int32}) Encountered unexpected error in runtime: MethodError(f=Base.Compiler.abstract_eval_basic_statement, args=(Base.Compiler.NativeInterpreter(world=0x00000000000096be, method_table=Base.Compiler.CachedMethodTable{Base.Compiler.InternalMethodTable}(cache=Base.IdDict{Base.Compiler.MethodMatchKey, Union{Nothing, Base.Compiler.MethodLookupResult}}(ht=Memory{Any}(512, 0x2af3700)[ #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Quadmath.Float128}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a42ff320)[Core.MethodMatch(spec_types=Tuple{Type{Quadmath.Float128}, Int64}, sparams=svec(), method=(::Type{Quadmath.Float128})(Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000967b, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Ref{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a451d4e0)[Core.MethodMatch(spec_types=Tuple{Type{Ref{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}}}, sparams=svec(GALAHAD.arc_control_type{Quadmath.Float128, Int32}), method=(::Type{Ref{T}})() where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002d5f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Accessors.IndexLens{I} where I<:Tuple}, Tuple{}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a2423ae0)[Core.MethodMatch(spec_types=Tuple{Type{Accessors.IndexLens{I} where I<:Tuple}, Tuple{}}, sparams=svec(Tuple{}), method=(::Type{Accessors.IndexLens{I} where I})(I) where {I<:Tuple}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009675, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.RefValue{T} where T}, GALAHAD.arc_control_type{Quadmath.Float128, Int32}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a1ef27c0)[Core.MethodMatch(spec_types=Tuple{Type{Base.RefValue{T} where T}, GALAHAD.arc_control_type{Quadmath.Float128, Int32}}, sparams=svec(GALAHAD.arc_control_type{Quadmath.Float128, Int32}), method=(::Type{Base.RefValue{T} where T})(T) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000cc7, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.rem), Int64, Type{UInt64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a424b200)[Core.MethodMatch(spec_types=Tuple{typeof(Base.rem), Int64, Type{UInt64}}, sparams=svec(), method=rem(Int64, Type{UInt64}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000b5a, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unsafe_convert), Type{Ptr{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}}, Base.RefValue{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a245e920)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_convert), Type{Ptr{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}}, Base.RefValue{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}}, sparams=svec(GALAHAD.arc_control_type{Quadmath.Float128, Int32}), method=unsafe_convert(Union{Type{Ptr{T}}, Type{Ptr{Nothing}}}, Base.RefValue{T}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000cc9, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.zeros), Type{Quadmath.Float128}, Int32}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a436dcc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.zeros), Type{Quadmath.Float128}, Int32}, sparams=svec(Quadmath.Float128), method=zeros(Type{T}, Union{Integer, Base.AbstractUnitRange{T} where T}...) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010d0, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unsafe_convert), Type{Int32}, Int32}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a2339ca0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_convert), Type{Int32}, Int32}, sparams=svec(Int32), method=unsafe_convert(Type{T}, T) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000384, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_rule), Type{Float64}, Type{Quadmath.Float128}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a21c9200)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_rule), Type{Float64}, Type{Quadmath.Float128}}, sparams=svec(), method=promote_rule(Type, Type), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000005fc, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Accessors.PropertyLens{:f_indexing}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a2423e80)[Core.MethodMatch(spec_types=Tuple{Type{Accessors.PropertyLens{:f_indexing}}}, sparams=svec(), method=(::Type{Accessors.PropertyLens{fieldname}})(), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009675, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Tuple{Vararg{Int64}}}, Tuple{Int32}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a435c860)[Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Tuple{Vararg{Int64}}}, Tuple{Int32}}, sparams=svec(1, Tuple{Vararg{Int64}}), method=convert(Type{T}, Tuple{Vararg{Any, N}}) where {N, T<:Tuple}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000377, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Ref{GALAHAD.arc_inform_type{Quadmath.Float128, Int32}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a451da20)[Core.MethodMatch(spec_types=Tuple{Type{Ref{GALAHAD.arc_inform_type{Quadmath.Float128, Int32}}}}, sparams=svec(GALAHAD.arc_inform_type{Quadmath.Float128, Int32}), method=(::Type{Ref{T}})() where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002d5f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.cconvert), Type{Ptr{Int8}}, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a23383a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.cconvert), Type{Ptr{Int8}}, String}, sparams=svec(), method=cconvert(Type{Ptr{Int8}}, AbstractString), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c79, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Type{Int32}, Vararg{Int64, 5}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a451e600)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Type{Int32}, Vararg{Int64, 5}}, sparams=svec(Int32), method=getindex(Type{T}, Any...) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010bd, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(GALAHAD.arc_initialize), Type{Quadmath.Float128}, Type{Int32}, Base.RefValue{Ptr{Nothing}}, Base.RefValue{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}, Base.RefValue{Int32}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a246d020)[Core.MethodMatch(spec_types=Tuple{typeof(GALAHAD.arc_initialize), Type{Quadmath.Float128}, Type{Int32}, Base.RefValue{Ptr{Nothing}}, Base.RefValue{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}, Base.RefValue{Int32}}, sparams=svec(), method=arc_initialize(Type{Quadmath.Float128}, Type{Int32}, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009687, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.zero), Type{Quadmath.Float128}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a42fe1a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.zero), Type{Quadmath.Float128}}, sparams=svec(Quadmath.Float128), method=zero(Type{T}) where {T<:Number}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000a7c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Int32}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a44b7520)[Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Int32}, Int64}, sparams=svec(Int32), method=convert(Type{T}, Number) where {T<:Number}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000a40, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.cconvert), Type{Float64}, Float64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a3da8be0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.cconvert), Type{Float64}, Float64}, sparams=svec(Float64), method=cconvert(Type{T}, Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000380, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unsafe_convert), Type{Ptr{Ptr{Nothing}}}, Base.RefValue{Ptr{Nothing}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a245e4c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_convert), Type{Ptr{Ptr{Nothing}}}, Base.RefValue{Ptr{Nothing}}}, sparams=svec(Ptr{Nothing}), method=unsafe_convert(Union{Type{Ptr{T}}, Type{Ptr{Nothing}}}, Base.RefValue{T}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000cc9, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.RefValue{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}}, GALAHAD.arc_control_type{Quadmath.Float128, Int32}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a1ef32c0)[Core.MethodMatch(spec_types=Tuple{Type{Base.RefValue{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}}, GALAHAD.arc_control_type{Quadmath.Float128, Int32}}, sparams=svec(GALAHAD.arc_control_type{Quadmath.Float128, Int32}), method=(::Type{Base.RefValue{T}})(Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000cc6, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Memory{Quadmath.Float128}}, UndefInitializer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a435eb80)[Core.MethodMatch(spec_types=Tuple{Type{Memory{Quadmath.Float128}}, UndefInitializer, Int64}, sparams=svec(Quadmath.Float128, Core.AddrSpace{Core}(0x00), :not_atomic), method=(::Type{GenericMemory{kind, T, addrspace}})(UndefInitializer, Int64) where {T, addrspace, kind}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000100, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(GALAHAD.arc_solve_reverse_with_mat), Type{Quadmath.Float128}, Type{Int32}, Base.RefValue{Ptr{Nothing}}, Base.RefValue{Int32}, Base.RefValue{Int32}, Int32, Array{Quadmath.Float128, 1}, Quadmath.Float128, Array{Quadmath.Float128, 1}, Int32, Array{Quadmath.Float128, 1}, Array{Quadmath.Float128, 1}, Array{Quadmath.Float128, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x73087a6f4920)[Core.MethodMatch(spec_types=Tuple{typeof(GALAHAD.arc_solve_reverse_with_mat), Type{Quadmath.Float128}, Type{Int32}, Base.RefValue{Ptr{Nothing}}, Base.RefValue{Int32}, Base.RefValue{Int32}, Int32, Array{Quadmath.Float128, 1}, Quadmath.Float128, Array{Quadmath.Float128, 1}, Int32, Array{Quadmath.Float128, 1}, Array{Quadmath.Float128, 1}, Array{Quadmath.Float128, 1}}, sparams=svec(), method=arc_solve_reverse_with_mat(Type{Quadmath.Float128}, Type{Int32}, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009687, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Quadmath.Float128}, Quadmath.Float128}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a21cb5c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Quadmath.Float128}, Quadmath.Float128}, sparams=svec(), method=convert(Type{Quadmath.Float128}, Number), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000967b, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unsafe_convert), Type{Int64}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a42d00e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_convert), Type{Int64}, Int64}, sparams=svec(Int64), method=unsafe_convert(Type{T}, T) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000384, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Array{Quadmath.Float128, 1}}, UndefInitializer, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a435d400)[Core.MethodMatch(spec_types=Tuple{Type{Array{Quadmath.Float128, 1}}, UndefInitializer, Tuple{Int64}}, sparams=svec(Quadmath.Float128), method=(::Type{Array{T, 1}})(UndefInitializer, Tuple{Int64}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000011b, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Quadmath.Float128}, Quadmath.Float128}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a21cbdc0)[Core.MethodMatch(spec_types=Tuple{Type{Quadmath.Float128}, Quadmath.Float128}, sparams=svec(), method=(::Type{Quadmath.Float128})(Quadmath.Float128), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000967b, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(GALAHAD.arc_import), Type{Quadmath.Float128}, Type{Int32}, Base.RefValue{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}, Base.RefValue{Ptr{Nothing}}, Base.RefValue{Int32}, Int32, String, Int32, Array{Int32, 1}, Array{Int32, 1}, Ptr{Nothing}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a2341200)[Core.MethodMatch(spec_types=Tuple{typeof(GALAHAD.arc_import), Type{Quadmath.Float128}, Type{Int32}, Base.RefValue{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}, Base.RefValue{Ptr{Nothing}}, Base.RefValue{Int32}, Int32, String, Int32, Array{Int32, 1}, Array{Int32, 1}, Ptr{Nothing}}, sparams=svec(), method=arc_import(Type{Quadmath.Float128}, Type{Int32}, Any, Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009687, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unsafe_convert), Type{Ptr{Nothing}}, GenericMemoryRef{:not_atomic, Quadmath.Float128, Core.AddrSpace{Core}(0x00)}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x73087a8a00e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_convert), Type{Ptr{Nothing}}, GenericMemoryRef{:not_atomic, Quadmath.Float128, Core.AddrSpace{Core}(0x00)}}, sparams=svec(Quadmath.Float128), method=unsafe_convert(Type{Ptr{Nothing}}, GenericMemoryRef{var"#s179", T, Core.AddrSpace{Core}(0x00)} where var"#s179") where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c83, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Ref{Quadmath.Float128}}, Float64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a3dc1f00)[Core.MethodMatch(spec_types=Tuple{Type{Ref{Quadmath.Float128}}, Float64}, sparams=svec(Quadmath.Float128), method=(::Type{Ref{T}})(Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002d60, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ConstructionBase.constructorof), Type{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a1d6eee0)[Core.MethodMatch(spec_types=Tuple{typeof(ConstructionBase.constructorof), Type{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}}, sparams=svec(), method=constructorof(Type), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000966e, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.rem), UInt32, Type{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x73087a9df0c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.rem), UInt32, Type{Int64}}, sparams=svec(), method=rem(UInt32, Type{Int64}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000b2b, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Type{Base.RefValue{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a244a760)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Type{Base.RefValue{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}}, Symbol}, sparams=svec(), method=getproperty(Type, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000027d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Quadmath.Float128}, Float64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a3da8080)[Core.MethodMatch(spec_types=Tuple{Type{Quadmath.Float128}, Float64}, sparams=svec(), method=(::Type{Quadmath.Float128})(Float64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000967b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unsafe_convert), Type{Ptr{Int32}}, Ptr{Nothing}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a233ab60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_convert), Type{Ptr{Int32}}, Ptr{Nothing}}, sparams=svec(Ptr{Int32}), method=unsafe_convert(Type{P}, Ptr{T} where T) where {P<:(Ptr{T} where T)}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000386, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Ref{Ptr{Nothing}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a451cf40)[Core.MethodMatch(spec_types=Tuple{Type{Ref{Ptr{Nothing}}}}, sparams=svec(Ptr{Nothing}), method=(::Type{Ref{T}})() where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002d5f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unsafe_convert), Type{Tuple{VecElement{Float64}, VecElement{Float64}}}, Tuple{VecElement{Float64}, VecElement{Float64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a20dc460)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_convert), Type{Tuple{VecElement{Float64}, VecElement{Float64}}}, Tuple{VecElement{Float64}, VecElement{Float64}}}, sparams=svec(Tuple{VecElement{Float64}, VecElement{Float64}}), method=unsafe_convert(Type{T}, T) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000384, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_rule), Type{Quadmath.Float128}, Type{Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a21c87c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_rule), Type{Quadmath.Float128}, Type{Float64}}, sparams=svec(), method=promote_rule(Type{Quadmath.Float128}, Type{Float64}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000967b, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.RefValue{Quadmath.Float128}}, Float64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a3dc29e0)[Core.MethodMatch(spec_types=Tuple{Type{Base.RefValue{Quadmath.Float128}}, Float64}, sparams=svec(Quadmath.Float128), method=(::Type{Base.RefValue{T}})(Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000cc6, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Array{Int32, 1}}, UndefInitializer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a44ec720)[Core.MethodMatch(spec_types=Tuple{Type{Array{Int32, 1}}, UndefInitializer, Int64}, sparams=svec(Int32), method=(::Type{Array{T, 1}})(UndefInitializer, Int64) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000117, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Ref{Int32}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a3dc03c0)[Core.MethodMatch(spec_types=Tuple{Type{Ref{Int32}}}, sparams=svec(Int32), method=(::Type{Ref{T}})() where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002d5f, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Ptr{Quadmath.Float128}}, Ptr{Nothing}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a20cc660)[Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Ptr{Quadmath.Float128}}, Ptr{Nothing}}, sparams=svec(Quadmath.Float128), method=convert(Type{Ptr{T}}, Ptr{T} where T) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c77, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.LazyString}, String, Int64, String, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x730879bd80a0)[Core.MethodMatch(spec_types=Tuple{Type{Base.LazyString}, String, Int64, String, String}, sparams=svec(), method=(::Type{Base.LazyString})(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000f1c, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Array{Quadmath.Float128, 1}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a41e8960)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Array{Quadmath.Float128, 1}, Tuple{Int64}}, sparams=svec(), method=(::Type{BoundsError})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000005f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.zeros), Type{Quadmath.Float128}, Tuple{Int32}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7308a47308e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.zeros), Type{Quadmath.Float128}, Tuple{Int32}}, sparams=svec(Quadmath.Float128, 1), method=zeros(Type{T}, Tuple{Vararg{Integer, N}}) where {T, N}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010d3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.cconvert), Type{Tuple{VecElement{Float64}, VecElement{Float64}}}, Quadmath.Float128}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x73087a756ae0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.cconvert), Type{Tuple{VecElement{Float64}, VecElement{Float64}}}, Quadmath.Float128}, sparams=svec(), method=cconvert(Type{Tuple{VecElement{Float64}, VecElement{Float64}}}, Quadmath.Float128), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000967b, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Int64}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x73087a8a7860)[Core.MethodMatch(spec_types=Tuple{Type{Int64}, Int64}, sparams=svec(), method=(::Type{Int64})(Union{Bool, Int128, Int16, Int32, Int64, Int8, UInt128, UInt16, UInt32, UInt64, UInt8}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000217, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.datatype_layoutsize), Type{Memory{Quadmath.Float128}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x73087a9dc8e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.datatype_layoutsize), Type{Memory{Quadmath.Float128}}}, sparams=svec(), method=datatype_layoutsize(typeof(DataType)), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000004ea, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_type), Type{Quadmath.Float128}, Type{Union{}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7308a237d1a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_type), Type{Quadmath.Float128}, Type{Union{}}}, sparams=svec(Quadmath.Float128), method=promote_type(Type{T}, Type{Union{}}) where {T}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000005f7, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unsafe_convert), Type{Ptr{Quadmath.Float128}}, GenericMemoryRef{:not_atomic, Quadmath.Float128, Core.AddrSpace{Core}(0x00)}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x73087a84f3c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_convert), Type{Ptr{Quadmath.Float128}}, GenericMemoryRef{:not_atomic, Quadmath.Float128, Core.AddrSpace{Core}(0x00)}}, sparams=svec(Quadmath.Float128), method=unsafe_convert(Type{Ptr{T}}, GenericMemoryRef{isatomic, T, addrspace} where addrspace where T where isatomic) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c84, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.cconvert), Type{Ptr{Int32}}, Ptr{Nothing}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a2338f20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.cconvert), Type{Ptr{Int32}}, Ptr{Nothing}}, sparams=svec(), method=cconvert(Type{var"#s65"} where var"#s65"<:(Ptr{T} where T), Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000382, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.cconvert), Type{Int64}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a42ffe20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.cconvert), Type{Int64}, Int64}, sparams=svec(Int64), method=cconvert(Type{T}, Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000380, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Int32}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a451e000)[Core.MethodMatch(spec_types=Tuple{Type{Int32}, Int64}, sparams=svec(), method=(::Type{Int32})(Union{Bool, Int128, Int16, Int32, Int64, Int8, UInt128, UInt16, UInt32, UInt64, UInt8}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000216, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Quadmath.Float128}, Float64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a3dc3820)[Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Quadmath.Float128}, Float64}, sparams=svec(), method=convert(Type{Quadmath.Float128}, Number), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000967b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.cconvert), Type{Ptr{Ptr{Nothing}}}, Base.RefValue{Ptr{Nothing}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a246ed80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.cconvert), Type{Ptr{Ptr{Nothing}}}, Base.RefValue{Ptr{Nothing}}}, sparams=svec(), method=cconvert(Type{var"#s65"} where var"#s65"<:(Ptr{T} where T), Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000382, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._fieldnames), Type{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a23d2d20)[Core.MethodMatch(spec_types=Tuple{typeof(Base._fieldnames), Type{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}}, sparams=svec(), method=_fieldnames(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000047b, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.one), Type{Quadmath.Float128}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x730879acf2e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.one), Type{Quadmath.Float128}}, sparams=svec(Quadmath.Float128), method=one(Type{T}) where {T<:Number}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000a7f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Val{2}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a2241ec0)[Core.MethodMatch(spec_types=Tuple{Type{Base.Val{2}}}, sparams=svec(), method=(::Type{Base.Val{x}})(), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000003be, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Memory{Int32}}, UndefInitializer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a44ed4e0)[Core.MethodMatch(spec_types=Tuple{Type{Memory{Int32}}, UndefInitializer, Int64}, sparams=svec(Int32, Core.AddrSpace{Core}(0x00), :not_atomic), method=(::Type{GenericMemory{kind, T, addrspace}})(UndefInitializer, Int64) where {T, addrspace, kind}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000100, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Quadmath.Float128}, Tuple{VecElement{Float64}, VecElement{Float64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a42d03c0)[Core.MethodMatch(spec_types=Tuple{Type{Quadmath.Float128}, Tuple{VecElement{Float64}, VecElement{Float64}}}, sparams=svec(), method=(::Type{Quadmath.Float128})(Tuple{VecElement{Float64}, VecElement{Float64}}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000967b, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Type{Tuple}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a23def00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Type{Tuple}, Symbol}, sparams=svec(), method=getproperty(Type, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000027d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Ref{T} where T}, GALAHAD.arc_control_type{Quadmath.Float128, Int32}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a1ef1f80)[Core.MethodMatch(spec_types=Tuple{Type{Ref{T} where T}, GALAHAD.arc_control_type{Quadmath.Float128, Int32}}, sparams=svec(), method=(::Type{Ref{T} where T})(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002d5e, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Quadmath.Float128}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a42feae0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Quadmath.Float128}, Int64}, sparams=svec(), method=convert(Type{Quadmath.Float128}, Number), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000967b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unsafe_convert), Type{Ptr{Int32}}, GenericMemoryRef{:not_atomic, Int32, Core.AddrSpace{Core}(0x00)}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a233a520)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_convert), Type{Ptr{Int32}}, GenericMemoryRef{:not_atomic, Int32, Core.AddrSpace{Core}(0x00)}}, sparams=svec(Int32), method=unsafe_convert(Type{Ptr{T}}, GenericMemoryRef{isatomic, T, addrspace} where addrspace where T where isatomic) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c84, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Ptr{Base.DataTypeLayout}}, Ptr{Nothing}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x73087a8a65a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Ptr{Base.DataTypeLayout}}, Ptr{Nothing}}, sparams=svec(Base.DataTypeLayout), method=convert(Type{Ptr{T}}, Ptr{T} where T) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c77, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.cconvert), Type{Int32}, Int32}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a2338060)[Core.MethodMatch(spec_types=Tuple{typeof(Base.cconvert), Type{Int32}, Int32}, sparams=svec(Int32), method=cconvert(Type{T}, Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000380, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.zeros), Type{Quadmath.Float128}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a2512b60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.zeros), Type{Quadmath.Float128}, Int64}, sparams=svec(Quadmath.Float128), method=zeros(Type{T}, Union{Integer, Base.AbstractUnitRange{T} where T}...) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010d0, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.fieldcount), Type{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a2407f80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.fieldcount), Type{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}}, sparams=svec(), method=fieldcount(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000053b, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unsafe_convert), Type{Float64}, Float64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a3da8f20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_convert), Type{Float64}, Float64}, sparams=svec(Float64), method=unsafe_convert(Type{T}, T) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000384, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Array{Quadmath.Float128, 1}}, UndefInitializer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a435dd80)[Core.MethodMatch(spec_types=Tuple{Type{Array{Quadmath.Float128, 1}}, UndefInitializer, Int64}, sparams=svec(Quadmath.Float128), method=(::Type{Array{T, 1}})(UndefInitializer, Int64) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000117, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.cconvert), Type{Ptr{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}}, Base.RefValue{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7308a3e3c9e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.cconvert), Type{Ptr{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}}, Base.RefValue{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}}, sparams=svec(), method=cconvert(Type{var"#s65"} where var"#s65"<:(Ptr{T} where T), Any), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000382, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{DomainError}, Int64, Base.LazyString}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x730879bd8300)[Core.MethodMatch(spec_types=Tuple{Type{DomainError}, Int64, Base.LazyString}, sparams=svec(), method=(::Type{DomainError})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000084, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.datatype_arrayelem), Type{Memory{Quadmath.Float128}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x73087a8a1b60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.datatype_arrayelem), Type{Memory{Quadmath.Float128}}}, sparams=svec(), method=datatype_arrayelem(typeof(DataType)), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000004e8, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.:(!==)), Any, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a1d53a60)[Core.MethodMatch(spec_types=Tuple{typeof(Core.:(!==)), Any, Any}, sparams=svec(), method=!==(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000025c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{GALAHAD.arc_control_type{T, INT} where INT where T}, Bool, Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, NTuple{31, Int8}, Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Bool, Bool, Bool, Bool, Bool, Bool, NTuple{31, Int8}, GALAHAD.rqs_control_type{Quadmath.Float128, Int32}, GALAHAD.glrt_control_type{Quadmath.Float128, Int32}, GALAHAD.dps_control_type{Quadmath.Float128, Int32}, GALAHAD.psls_control_type{Quadmath.Float128, Int32}, GALAHAD.lms_control_type{Int32}, GALAHAD.lms_control_type{Int32}, GALAHAD.sha_control_type{Int32}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a1e1dde0)[Core.MethodMatch(spec_types=Tuple{Type{GALAHAD.arc_control_type{T, INT} where INT where T}, Bool, Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, NTuple{31, Int8}, Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Quadmath.Float128, Bool, Bool, Bool, Bool, Bool, Bool, NTuple{31, Int8}, GALAHAD.rqs_control_type{Quadmath.Float128, Int32}, GALAHAD.glrt_control_type{Quadmath.Float128, Int32}, GALAHAD.dps_control_type{Quadmath.Float128, Int32}, GALAHAD.psls_control_type{Quadmath.Float128, Int32}, GALAHAD.lms_control_type{Int32}, GALAHAD.lms_control_type{Int32}, GALAHAD.sha_control_type{Int32}}, sparams=svec(Quadmath.Float128, Int32), method=(::Type{GALAHAD.arc_control_type{T, INT} where INT where T})(Bool, INT, INT, INT, INT, INT, INT, INT, INT, NTuple{31, Int8}, INT, INT, INT, INT, INT, INT, INT, INT, INT, INT, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, Bool, Bool, Bool, Bool, Bool, Bool, NTuple{31, Int8}, GALAHAD.rqs_control_type{T, INT}, GALAHAD.glrt_control_type{T, INT}, GALAHAD.dps_control_type{T, INT}, GALAHAD.psls_control_type{T, INT}, GALAHAD.lms_control_type{INT}, GALAHAD.lms_control_type{INT}, GALAHAD.sha_control_type{INT}) where {T, INT}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009687, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Array{Quadmath.Float128, 1}}, UndefInitializer, Tuple{Int32}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a436f7e0)[Core.MethodMatch(spec_types=Tuple{Type{Array{Quadmath.Float128, 1}}, UndefInitializer, Tuple{Int32}}, sparams=svec(Quadmath.Float128, 1), method=(::Type{Array{T, N}})(UndefInitializer, Tuple{Vararg{Integer, N}}) where {T, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000150a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.allocatedinline), Type{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a2450700)[Core.MethodMatch(spec_types=Tuple{typeof(Base.allocatedinline), Type{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}}, sparams=svec(), method=allocatedinline(Type), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001097, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{NamedTuple{(:f_indexing,), T} where T<:Tuple}, Tuple{Bool}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a2404140)[Core.MethodMatch(spec_types=Tuple{Type{NamedTuple{(:f_indexing,), T} where T<:Tuple}, Tuple{Bool}}, sparams=svec((:f_indexing,)), method=(::Type{NamedTuple{names, T} where T<:Tuple})(Tuple) where {names}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000183, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Ptr{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}}, Ptr{Nothing}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a2431cc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Ptr{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}}, Ptr{Nothing}}, sparams=svec(GALAHAD.arc_control_type{Quadmath.Float128, Int32}), method=convert(Type{Ptr{T}}, Ptr{T} where T) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c77, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.cconvert), Type{Ptr{Int32}}, Array{Int32, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a23388e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.cconvert), Type{Ptr{Int32}}, Array{Int32, 1}}, sparams=svec(), method=cconvert(Type{var"#s179"} where var"#s179"<:(Ptr{T} where T), Array{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c7c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.cconvert), Type{Ptr{Int32}}, Base.RefValue{Int32}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a245e080)[Core.MethodMatch(spec_types=Tuple{typeof(Base.cconvert), Type{Ptr{Int32}}, Base.RefValue{Int32}}, sparams=svec(), method=cconvert(Type{var"#s65"} where var"#s65"<:(Ptr{T} where T), Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000382, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unsafe_convert), Type{Ptr{Int32}}, Base.RefValue{Int32}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a2423800)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_convert), Type{Ptr{Int32}}, Base.RefValue{Int32}}, sparams=svec(Int32), method=unsafe_convert(Union{Type{Ptr{T}}, Type{Ptr{Nothing}}}, Base.RefValue{T}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000cc9, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Type{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a23e8c40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Type{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}, Symbol}, sparams=svec(), method=getproperty(Type, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000027d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isabstracttype), Type{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a23dc160)[Core.MethodMatch(spec_types=Tuple{typeof(Base.isabstracttype), Type{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}}, sparams=svec(), method=isabstracttype(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000051f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.cconvert), Type{Ptr{Quadmath.Float128}}, Array{Quadmath.Float128, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7308a1f02820)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.cconvert), Type{Ptr{Quadmath.Float128}}, Array{Quadmath.Float128, 1}}, sparams=svec(), method=cconvert(Type{var"#s179"} where var"#s179"<:(Ptr{T} where T), Array{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c7c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_type), Type{Quadmath.Float128}, Type{Quadmath.Float128}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7308a210d120)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_type), Type{Quadmath.Float128}, Type{Quadmath.Float128}}, sparams=svec(Quadmath.Float128), method=promote_type(Type{T}, Type{T}) where {T}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000005f6, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Type{Memory{Quadmath.Float128}}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x73087a8a2cc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Type{Memory{Quadmath.Float128}}, Symbol}, sparams=svec(), method=getproperty(Type, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000027d, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.fieldnames), Type{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a2407420)[Core.MethodMatch(spec_types=Tuple{typeof(Base.fieldnames), Type{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}}, sparams=svec(), method=fieldnames(typeof(DataType)), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000004b6, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Main.userdata_arc{T} where T}, Float64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a451dd00)[Core.MethodMatch(spec_types=Tuple{Type{Main.userdata_arc{T} where T}, Float64}, sparams=svec(Float64), method=(::Type{Main.userdata_arc{T} where T})(T) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000969d, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Type{Quadmath.Float128}, Float64, Float64, Float64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a208d6c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Type{Quadmath.Float128}, Float64, Float64, Float64}, sparams=svec(Quadmath.Float128), method=getindex(Type{T}, Any...) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010bd, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Accessors.OpticStyle}, Type{Base.ComposedFunction{Accessors.PropertyLens{:f_indexing}, Accessors.IndexLens{Tuple{}}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a2414ea0)[Core.MethodMatch(spec_types=Tuple{Type{Accessors.OpticStyle}, Type{Base.ComposedFunction{Accessors.PropertyLens{:f_indexing}, Accessors.IndexLens{Tuple{}}}}}, sparams=svec(Accessors.PropertyLens{:f_indexing}, Accessors.IndexLens{Tuple{}}), method=(::Type{Accessors.OpticStyle})(Type{Base.ComposedFunction{O, I}}) where {O, I}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009675, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Type{Int32}, Vararg{Int64, 4}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a43d5e80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Type{Int32}, Vararg{Int64, 4}}, sparams=svec(Int32), method=getindex(Type{T}, Any...) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010bd, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Printf.format), IO, Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a3dc1180)[Core.MethodMatch(spec_types=Tuple{typeof(Printf.format), IO, Printf.Format{Base.CodeUnits{UInt8, String}, Tuple{}}}, sparams=svec(0), method=format(IO, Printf.Format{S, T} where T where S, Vararg{Any, N}) where {N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009672, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_type), Type{Quadmath.Float128}, Type{Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a21bf9a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_type), Type{Quadmath.Float128}, Type{Float64}}, sparams=svec(Quadmath.Float128, Float64), method=promote_type(Type{T}, Type{S}) where {T, S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000005f9, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.zeros), Type{Quadmath.Float128}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7308a3f3c8e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.zeros), Type{Quadmath.Float128}, Tuple{Int64}}, sparams=svec(Quadmath.Float128, 1), method=zeros(Type{T}, Tuple{Vararg{Integer, N}}) where {T, N}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010d3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.datatype_fieldcount), Type{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a23fe8e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.datatype_fieldcount), Type{GALAHAD.arc_control_type{Quadmath.Float128, Int32}}}, sparams=svec(), method=datatype_fieldcount(typeof(DataType)), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000539, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unsafe_convert), Type{Ptr{Int8}}, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a2339fe0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_convert), Type{Ptr{Int8}}, String}, sparams=svec(), method=unsafe_convert(Type{Ptr{Int8}}, String), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000388, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_result), Type{Quadmath.Float128}, Type{Float64}, Type{Quadmath.Float128}, Type{Union{}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7308a21c9c80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_result), Type{Quadmath.Float128}, Type{Float64}, Type{Quadmath.Float128}, Type{Union{}}}, sparams=svec(Quadmath.Float128, Union{}), method=promote_result(Type, Type, Type{T}, Type{S})T, ARC -- Float128 -- Int32: Error During Test at /home/pkgeval/.julia/packages/GALAHAD/R5ALk/test/test_arc.jl:328 Test threw exception Expression: test_arc(T, INT) == 0 StackOverflowError: Stacktrace: [1] macro expansion @ /opt/julia/share/julia/stdlib/v1.12/Test/src/Test.jl:677 [inlined] [2] macro expansion @ ~/.julia/packages/GALAHAD/R5ALk/test/test_arc.jl:328 [inlined] [3] macro expansion @ /opt/julia/share/julia/stdlib/v1.12/Test/src/Test.jl:1776 [inlined] [4] top-level scope @ ~/.julia/packages/GALAHAD/R5ALk/test/test_arc.jl:328 caused by: MethodError: no method matching abstract_eval_basic_statement(::Compiler.NativeInterpreter, ::QuoteNode, ::Compiler.StatementState, ::Compiler.IRInterpretationState) The function `abstract_eval_basic_statement` exists, but no method is defined for this combination of argument types. Closest candidates are: abstract_eval_basic_statement(::Compiler.AbstractInterpreter, ::Any, ::Compiler.StatementState, !Matched::Compiler.InferenceState, !Matched::Union{Nothing, Compiler.Future{Compiler.RTEffects}}) @ Base /opt/julia/share/julia/Compiler/src/abstractinterpretation.jl:3782 abstract_eval_basic_statement(::Compiler.AbstractInterpreter, ::Any, ::Compiler.StatementState, !Matched::Compiler.InferenceState) @ Base /opt/julia/share/julia/Compiler/src/abstractinterpretation.jl:3782 Stacktrace: [1] abstract_eval_nonlinearized_foreigncall_name(interp::Compiler.NativeInterpreter, e::QuoteNode, sstate::Compiler.StatementState, sv::Compiler.IRInterpretationState) @ Compiler ./../usr/share/julia/Compiler/src/abstractinterpretation.jl:3483 [2] abstract_eval_foreigncall(interp::Compiler.NativeInterpreter, e::Expr, sstate::Compiler.StatementState, sv::Compiler.IRInterpretationState) @ Compiler ./../usr/share/julia/Compiler/src/abstractinterpretation.jl:3491 [3] abstract_eval_statement_expr(interp::Compiler.NativeInterpreter, e::Expr, sstate::Compiler.StatementState, sv::Compiler.IRInterpretationState) @ Compiler ./../usr/share/julia/Compiler/src/abstractinterpretation.jl:3397 [4] reprocess_instruction!(interp::Compiler.NativeInterpreter, inst::Compiler.Instruction, idx::Int64, bb::Int64, irsv::Compiler.IRInterpretationState) @ Compiler ./../usr/share/julia/Compiler/src/ssair/irinterp.jl:154 [5] (::Compiler.var"#221#222"{Nothing, Compiler.NativeInterpreter, Compiler.IRInterpretationState, Compiler.var"#check_ret!#220"{Vector{Int64}}, BitSet, Compiler.TwoPhaseDefUseMap, Compiler.IRCode})(inst::Compiler.Instruction, lstmt::Int64, bb::Int64) @ Compiler ./../usr/share/julia/Compiler/src/ssair/irinterp.jl:364 [6] scan!(callback::Compiler.var"#221#222"{Nothing, Compiler.NativeInterpreter, Compiler.IRInterpretationState, Compiler.var"#check_ret!#220"{Vector{Int64}}, BitSet, Compiler.TwoPhaseDefUseMap, Compiler.IRCode}, scanner::Compiler.BBScanner, forwards_only::Bool) @ Compiler ./../usr/share/julia/Compiler/src/ssair/irinterp.jl:286 [7] ir_abstract_constant_propagation(interp::Compiler.NativeInterpreter, irsv::Compiler.IRInterpretationState; externally_refined::Nothing) @ Compiler ./../usr/share/julia/Compiler/src/ssair/irinterp.jl:332 [8] ir_abstract_constant_propagation(interp::Compiler.NativeInterpreter, irsv::Compiler.IRInterpretationState) @ Compiler ./../usr/share/julia/Compiler/src/ssair/irinterp.jl:318 [9] semi_concrete_eval_call(interp::Compiler.NativeInterpreter, mi::Core.MethodInstance, result::Compiler.MethodCallResult, arginfo::Compiler.ArgInfo, sv::Compiler.InferenceState) @ Compiler ./../usr/share/julia/Compiler/src/abstractinterpretation.jl:1265 [10] abstract_call_method_with_const_args(interp::Compiler.NativeInterpreter, result::Compiler.MethodCallResult, f::Any, arginfo::Compiler.ArgInfo, si::Compiler.StmtInfo, match::Core.MethodMatch, sv::Compiler.InferenceState, invokecall::Nothing) @ Compiler ./../usr/share/julia/Compiler/src/abstractinterpretation.jl:892 [11] abstract_call_method_with_const_args(interp::Compiler.NativeInterpreter, result::Compiler.MethodCallResult, f::Any, arginfo::Compiler.ArgInfo, si::Compiler.StmtInfo, match::Core.MethodMatch, sv::Compiler.InferenceState) @ Compiler ./../usr/share/julia/Compiler/src/abstractinterpretation.jl:868 [12] (::Compiler.var"#handle1#abstract_call_gf_by_type##1"{Int64, Compiler.Future{Compiler.MethodCallResult}, Int64, Vector{Union{Nothing, Core.CodeInstance}}, Core.MethodMatch, Compiler.ArgInfo, Compiler.StmtInfo, Compiler.CallInferenceState, Vector{Any}, Compiler.var"#tmerge##0#tmerge##1"{Compiler.InferenceLattice{Compiler.ConditionalsLattice{Compiler.PartialsLattice{Compiler.ConstsLattice}}}}, Compiler.var"#tmerge##0#tmerge##1"{Compiler.InferenceLattice{Compiler.InterConditionalsLattice{Compiler.PartialsLattice{Compiler.ConstsLattice}}}}, Compiler.var"#⊑##0#⊑##1"{Compiler.InferenceLattice{Compiler.InterConditionalsLattice{Compiler.PartialsLattice{Compiler.ConstsLattice}}}}, Compiler.InferenceLattice{Compiler.ConditionalsLattice{Compiler.PartialsLattice{Compiler.ConstsLattice}}}, Compiler.InferenceLattice{Compiler.InterConditionalsLattice{Compiler.PartialsLattice{Compiler.ConstsLattice}}}})(interp::Compiler.NativeInterpreter, sv::Compiler.InferenceState) @ Compiler ./../usr/share/julia/Compiler/src/abstractinterpretation.jl:178 [13] doworkloop(interp::Compiler.NativeInterpreter, sv::Compiler.InferenceState) @ Compiler ./../usr/share/julia/Compiler/src/inferencestate.jl:1205 [14] typeinf(interp::Compiler.NativeInterpreter, frame::Compiler.InferenceState) @ Compiler ./../usr/share/julia/Compiler/src/abstractinterpretation.jl:4484 [15] typeinf_ext(interp::Compiler.NativeInterpreter, mi::Core.MethodInstance, source_mode::UInt8) @ Compiler ./../usr/share/julia/Compiler/src/typeinfer.jl:1259 [16] typeinf_ext_toplevel @ ./../usr/share/julia/Compiler/src/typeinfer.jl:1442 [inlined] [17] typeinf_ext_toplevel(mi::Core.MethodInstance, world::UInt64, source_mode::UInt8, trim_mode::UInt8) @ Compiler ./../usr/share/julia/Compiler/src/typeinfer.jl:1451 [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.12/Test/src/Test.jl:677 [inlined] [19] macro expansion @ ~/.julia/packages/GALAHAD/R5ALk/test/test_arc.jl:328 [inlined] [20] macro expansion @ /opt/julia/share/julia/stdlib/v1.12/Test/src/Test.jl:1776 [inlined] [21] top-level scope @ ~/.julia/packages/GALAHAD/R5ALk/test/test_arc.jl:328 Test Summary: | Error Total Time ARC -- Float128 -- Int32 | 1 1 9.7s RNG of the outermost testset: Random.Xoshiro(0x1049e376592c8d83, 0x82b8b684c1f94e9b, 0x4b03b268ed71effd, 0x78701bfdc8a301b3, 0x5a974701bec7352a) ERROR: LoadError: Some tests did not pass: 0 passed, 0 failed, 1 errored, 0 broken. in expression starting at /home/pkgeval/.julia/packages/GALAHAD/R5ALk/test/test_arc.jl:320 in expression starting at /home/pkgeval/.julia/packages/GALAHAD/R5ALk/test/runtests.jl:8 Testing failed after 56.3s ERROR: LoadError: Package GALAHAD errored during testing Stacktrace: [1] pkgerror(msg::String) @ Pkg.Types /opt/julia/share/julia/stdlib/v1.12/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.12/Pkg/src/Operations.jl:2458 [3] test @ /opt/julia/share/julia/stdlib/v1.12/Pkg/src/Operations.jl:2313 [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.12/Pkg/src/API.jl:511 [5] test(pkgs::Vector{PackageSpec}; io::IOContext{IO}, kwargs::@Kwargs{julia_args::Cmd}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.12/Pkg/src/API.jl:164 [6] test(pkgs::Vector{String}; kwargs::@Kwargs{julia_args::Cmd}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.12/Pkg/src/API.jl:152 [7] test @ /opt/julia/share/julia/stdlib/v1.12/Pkg/src/API.jl:152 [inlined] [8] #test#81 @ /opt/julia/share/julia/stdlib/v1.12/Pkg/src/API.jl:151 [inlined] [9] top-level scope @ /PkgEval.jl/scripts/evaluate.jl:219 [10] include(mod::Module, _path::String) @ Base ./Base.jl:305 [11] exec_options(opts::Base.JLOptions) @ Base ./client.jl:321 [12] _start() @ Base ./client.jl:554 in expression starting at /PkgEval.jl/scripts/evaluate.jl:210 PkgEval crashed after 119.02s: an internal error was encountered