Package evaluation of JSOSolvers on Julia 1.12.0-rc1.2 (995ff9db19*) started at 2025-07-14T12:27:36.327 ################################################################################ # Set-up # Installing PkgEval dependencies (TestEnv)... Set-up completed after 8.91s ################################################################################ # Installation # Installing JSOSolvers... Resolving package versions... Updating `~/.julia/environments/v1.12/Project.toml` [10dff2fc] + JSOSolvers v0.14.0 Updating `~/.julia/environments/v1.12/Manifest.toml` [e2ba6199] + ExprTools v0.1.10 [9aa1b823] + FastClosures v0.3.2 [10dff2fc] + JSOSolvers v0.14.0 [ba0b0d4f] + Krylov v0.10.1 [5c8ed15e] + LinearOperators v2.10.0 [a4795742] + NLPModels v0.21.5 [e01155f1] + NLPModelsModifiers v0.7.2 [ae029012] + Requires v1.3.1 [ff4d7338] + SolverCore v0.3.8 [d076d87d] + SolverParameters v0.1.2 [b5612192] + SolverTools v0.9.0 [a759f4b9] + TimerOutputs v0.5.29 [56f22d72] + Artifacts v1.11.0 [8f399da3] + Libdl v1.11.0 [37e2e46d] + LinearAlgebra v1.12.0 [56ddb016] + Logging v1.11.0 [de0858da] + Printf v1.11.0 [9a3f8284] + Random v1.11.0 [ea8e919c] + SHA v0.7.0 [9e88b42a] + Serialization v1.11.0 [2f01184e] + SparseArrays v1.12.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 [bea87d4a] + SuiteSparse_jll v7.8.3+2 [8e850b90] + libblastrampoline_jll v5.13.1+0 Installation completed after 3.7s ################################################################################ # Precompilation # Precompiling PkgEval dependencies... Precompiling package dependencies... Precompilation completed after 279.58s ################################################################################ # Testing # Testing JSOSolvers Status `/tmp/jl_0Ywd8J/Project.toml` [54578032] ADNLPModels v0.8.12 [10dff2fc] JSOSolvers v0.14.0 [ba0b0d4f] Krylov v0.10.1 [5c8ed15e] LinearOperators v2.10.0 [a4795742] NLPModels v0.21.5 [e01155f1] NLPModelsModifiers v0.7.2 [7998695d] NLPModelsTest v0.10.2 [ff4d7338] SolverCore v0.3.8 [d076d87d] SolverParameters v0.1.2 [4343dc35] SolverTest v0.3.17 [b5612192] SolverTools v0.9.0 [37e2e46d] LinearAlgebra v1.12.0 [56ddb016] Logging v1.11.0 [de0858da] Printf v1.11.0 [2f01184e] SparseArrays v1.12.0 [8dfed614] Test v1.11.0 Status `/tmp/jl_0Ywd8J/Manifest.toml` [54578032] ADNLPModels v0.8.12 [47edcb42] ADTypes v1.15.0 [14f7f29c] AMD v0.5.3 [66dad0bd] AliasTables v1.1.3 [d360d2e6] ChainRulesCore v1.25.2 [944b1d66] CodecZlib v0.7.8 [35d6a980] ColorSchemes v3.30.0 [3da002f7] ColorTypes v0.12.1 [c3611d14] ColorVectorSpace v0.11.0 [5ae59095] Colors v0.13.1 [bbf7d656] CommonSubexpressions v0.3.1 [34da2185] Compat v4.17.0 [d38c429a] Contour v0.6.3 [a8cc5b0e] Crayons v4.1.1 [9a962f9c] DataAPI v1.16.0 [864edb3b] DataStructures v0.18.22 [8bb1440f] DelimitedFiles v1.9.1 [163ba53b] DiffResults v1.1.0 [b552c78f] DiffRules v1.15.1 [ffbed154] DocStringExtensions v0.9.5 [e2ba6199] ExprTools v0.1.10 [9aa1b823] FastClosures v0.3.2 [1a297f60] FillArrays v1.13.0 [53c48c17] FixedPointNumbers v0.8.5 [f6369f11] ForwardDiff v1.0.1 [069b7b12] FunctionWrappers v1.1.3 [34c5aeac] HSL v0.5.1 [92d709cd] IrrationalConstants v0.2.4 [692b3bcd] JLLWrappers v1.7.0 [10dff2fc] JSOSolvers v0.14.0 [ba0b0d4f] Krylov v0.10.1 [40e66cde] LDLFactorizations v0.10.1 [39f5bc3e] LLSModels v0.5.0 [f5a24dde] LimitedLDLFactorizations v0.5.2 [5c8ed15e] LinearOperators v2.10.0 [2ab3a3ac] LogExpFunctions v0.3.29 [1914dd2f] MacroTools v0.5.16 [299715c1] MarchingCubes v0.1.11 [4d4711f2] MatrixMarket v0.5.2 [e1d29d7a] Missings v1.2.0 [a4795742] NLPModels v0.21.5 [e01155f1] NLPModelsModifiers v0.7.2 [7998695d] NLPModelsTest v0.10.2 [77ba4419] NaNMath v1.1.3 [c32e1cdf] OperatorScaling v0.1.0 [bac558e1] OrderedCollections v1.8.1 [aea7be01] PrecompileTools v1.3.2 [21216c6a] Preferences v1.4.3 [43287f4e] PtrArrays v1.3.0 [be4d8f0f] Quadmath v0.5.13 [f468eda6] QuadraticModels v0.9.13 [189a3867] Reexport v1.2.2 [ae029012] Requires v1.3.1 [37e2e3b7] ReverseDiff v1.16.1 [1e40b3f8] RipQP v0.7.0 [ff4d7338] SolverCore v0.3.8 [d076d87d] SolverParameters v0.1.2 [4343dc35] SolverTest v0.3.17 [b5612192] SolverTools v0.9.0 [a2af1166] SortingAlgorithms v1.2.1 [9f842d2f] SparseConnectivityTracer v0.6.21 [fa32481b] SparseMatricesCOO v0.2.4 [0a514795] SparseMatrixColorings v0.4.21 [276daf66] SpecialFunctions v2.5.1 [90137ffa] StaticArrays v1.9.13 [1e83bf80] StaticArraysCore v1.4.3 [10745b16] Statistics v1.11.1 [82ae8749] StatsAPI v1.7.1 [2913bbd2] StatsBase v0.34.5 [62fd8b95] TensorCore v0.1.1 [a759f4b9] TimerOutputs v0.5.29 [3bb67fe8] TranscodingStreams v0.11.3 [b8865327] UnicodePlots v3.8.1 [017b0a0e] HSL_jll v4.0.2+0 [656ef2d0] OpenBLAS32_jll v0.3.29+0 [efe28fd5] OpenSpecFun_jll v0.5.6+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 [a63ad114] Mmap v1.11.0 [de0858da] Printf v1.11.0 [9a3f8284] Random v1.11.0 [ea8e919c] SHA v0.7.0 [9e88b42a] Serialization v1.11.0 [2f01184e] SparseArrays v1.12.0 [f489334b] StyledStrings v1.11.0 [4607b0f0] SuiteSparse [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 [05823500] OpenLibm_jll v0.8.5+0 [bea87d4a] SuiteSparse_jll v7.8.3+2 [83775a58] Zlib_jll v1.3.1+2 [8e850b90] libblastrampoline_jll v5.13.1+0 Testing Running tests... Test Summary: | Pass Total Time Test small residual checks TrunkSolverNLS | 2 2 38.2s Test Summary: | Pass Total Time Test small residual checks TronSolverNLS | 2 2 7.1s Test Summary: | Pass Total Time Test iteration limit | 7 7 42.8s Test Summary: | Pass Total Time Test unbounded below | 10 10 6.7s Test Summary: | Pass Total Time Test restart with a different initial guess: R2 | 4 4 2.0s Test Summary: | Pass Total Time Test restart with a different initial guess: fomo | 4 4 5.4s Test Summary: | Pass Total Time Test restart with a different initial guess: lbfgs | 4 4 1.3s Test Summary: | Pass Total Time Test restart with a different initial guess: tron | 4 4 2.2s Test Summary: | Pass Total Time Test restart with a different initial guess: trunk | 4 4 1.6s Test Summary: | Pass Total Time Test restart NLS with a different initial guess: tron | 4 4 5.2s Test Summary: | Pass Total Time Test restart NLS with a different initial guess: trunk | 4 4 1.5s Test Summary: | Pass Total Time Test restart with a different problem: R2 | 4 4 2.1s Test Summary: | Pass Total Time Test restart with a different problem: fomo | 4 4 0.0s Test Summary: | Pass Total Time Test restart with a different problem: lbfgs | 4 4 0.1s Test Summary: | Pass Total Time Test restart with a different problem: tron | 4 4 1.3s Test Summary: | Pass Total Time Test restart with a different problem: trunk | 4 4 0.0s Test Summary: | Pass Total Time Test restart NLS with a different problem: tron | 4 4 6.2s Test Summary: | Pass Total Time Test restart NLS with a different problem: trunk | 4 4 0.0s Test Summary: | Pass Total Time Test callback | 5 5 12.7s Test Summary: | Pass Total Time Test callback for NLS | 2 2 8.0s Test Summary: | Pass Total Time Testing Solver Values | 1 1 2.8s Test Summary: | Pass Total Time Consistency | 36 36 43.3s Internal error: during type inference of tests() Encountered unexpected error in runtime: MethodError(f=Base.Compiler.abstract_eval_basic_statement, args=(Base.Compiler.NativeInterpreter(world=0x00000000000097bf, method_table=Base.Compiler.CachedMethodTable{Base.Compiler.InternalMethodTable}(cache=Base.IdDict{Base.Compiler.MethodMatchKey, Union{Nothing, Base.Compiler.MethodLookupResult}}(ht=Memory{Any}(32768, 0x4bfa980)[ Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.Unknown, typeof(LinearOperators.storage_type), Tuple{Tuple{Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T, LinearOperators.LinearOperator{_A, Int64, LinearOperators.var"#119#120", LinearOperators.var"#119#120", LinearOperators.var"#119#120", T} where T where _A}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228bd35380)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.Unknown, typeof(LinearOperators.storage_type), Tuple{Tuple{Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T, LinearOperators.LinearOperator{_A, Int64, LinearOperators.var"#119#120", LinearOperators.var"#119#120", LinearOperators.var"#119#120", T} where T where _A}}}, sparams=svec(typeof(LinearOperators.storage_type)), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseArrays.CHOLMOD.change_factor!), SparseArrays.CHOLMOD.Factor{Float64, Ti} where Ti<:Union{Int32, Int64}, Vararg{Bool, 4}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x742282ece0a0)[ Core.MethodMatch(spec_types=Tuple{typeof(SparseArrays.CHOLMOD.change_factor!), SparseArrays.CHOLMOD.Factor{Float64, Int32}, Vararg{Bool, 4}}, sparams=svec(Float64), method=change_factor!(SparseArrays.CHOLMOD.Factor{Tv, Int32}, Bool, Bool, Bool, Bool) where {Tv<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(SparseArrays.CHOLMOD.change_factor!), SparseArrays.CHOLMOD.Factor{Float64, Int64}, Vararg{Bool, 4}}, sparams=svec(Float64), method=change_factor!(SparseArrays.CHOLMOD.Factor{Tv, Int64}, Bool, Bool, Bool, Bool) where {Tv<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009675, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), Any, Base.RefValue{T} where T, AbstractArray{Float64, 1}, AbstractArray{Float64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742283721860)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), Any, Base.RefValue{T} where T, AbstractArray{Float64, 1}, AbstractArray{Float64, 1}}, sparams=svec(), method=combine_styles(Any, Any, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004833, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isempty), Array{T, 1} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226ed6db60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.isempty), Array{T, 1} where T<:Real}, sparams=svec(), method=isempty(AbstractArray{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012c4, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.fd_refinement), RipQP.Abstract_QM_FloatData{Float64, S, M1, M2} where M2<:Union{AbstractArray{Float64, 2}, LinearOperators.AbstractLinearOperator{Float64}} where M1<:Union{AbstractArray{Float64, 2}, LinearOperators.AbstractLinearOperator{Float64}} where S<:AbstractArray{Float64, 1}, RipQP.QM_IntData, RipQP.AbstractResiduals{T, S} where S where T<:Real, Any, RipQP.Point{T, S} where S where T<:Real, RipQP.IterData{T, S} where S where T<:Real, RipQP.Tolerances{Float64}, RipQP.DescentDirectionAllocs{T, S} where S where T<:Real, RipQP.PreallocatedDataK2LDL{Float64, _A, F, M} where M<:AbstractArray{Float64, 2} where F<:(RipQP.LDLFactorizationData{T} where T) where _A, RipQP.StartingPointData{T, S} where S where T<:Real, RipQP.Counters, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742287c68b40)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.fd_refinement), RipQP.QM_FloatData{Float64, S, M1, M2} where M2<:Union{AbstractArray{Float64, 2}, LinearOperators.AbstractLinearOperator{Float64}} where M1<:Union{AbstractArray{Float64, 2}, LinearOperators.AbstractLinearOperator{Float64}} where S<:AbstractArray{Float64, 1}, RipQP.QM_IntData, RipQP.AbstractResiduals{Float64, S} where S, Array{Float64, 1}, RipQP.Point{Float64, S} where S, RipQP.IterData{Float64, S} where S, RipQP.Tolerances{Float64}, RipQP.DescentDirectionAllocs{Float64, S} where S, RipQP.PreallocatedDataK2LDL{Float64, _A, F, M} where M<:AbstractArray{Float64, 2} where F<:(RipQP.LDLFactorizationData{T} where T) where _A, RipQP.StartingPointData{Float64, S} where S, RipQP.Counters, Symbol}, sparams=svec(Float64), method=fd_refinement(RipQP.QM_FloatData{T, S, M1, M2} where M2 where M1 where S, RipQP.QM_IntData, RipQP.AbstractResiduals{T, S} where S, Array{T, 1}, RipQP.Point{T, S} where S, RipQP.IterData{T, S} where S, RipQP.Tolerances{T}, RipQP.DescentDirectionAllocs{T, S} where S, RipQP.PreallocatedData{T, S} where S, RipQP.StartingPointData{T, S} where S, RipQP.Counters, Symbol) where {T<:Real}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unaliascopy), Array{T, 1} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422aa3af000)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unaliascopy), Array{T, 1} where T<:Real}, sparams=svec(), method=unaliascopy(Array{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000130b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{ft} where ft<:(Array{R, 1} where R), Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74228578f6e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Int64}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000034c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{RipQP.var"##iter!#116", Bool, typeof(RipQP.iter!), RipQP.Point{Float64, S} where S, RipQP.IterData{Float64, S} where S, RipQP.Abstract_QM_FloatData{Float64, S, M1, M2} where M2<:Union{AbstractArray{Float64, 2}, LinearOperators.AbstractLinearOperator{Float64}} where M1<:Union{AbstractArray{Float64, 2}, LinearOperators.AbstractLinearOperator{Float64}} where S<:AbstractArray{Float64, 1}, RipQP.QM_IntData, RipQP.AbstractResiduals{Float64, S} where S, RipQP.StopCrit{Float64}, RipQP.DescentDirectionAllocs{Float64, S} where S, RipQP.PreallocatedDataK2LDL{Float64, _A, F, M} where M<:AbstractArray{Float64, 2} where F<:(RipQP.LDLFactorizationData{T} where T) where _A, RipQP.Tolerances{Float64}, RipQP.Counters, RipQP.InputConfig{Int64}, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d7cee00)[Core.MethodMatch(spec_types=Tuple{RipQP.var"##iter!#116", Bool, typeof(RipQP.iter!), RipQP.Point{Float64, S} where S, RipQP.IterData{Float64, S} where S, RipQP.Abstract_QM_FloatData{Float64, S, M1, M2} where M2<:Union{AbstractArray{Float64, 2}, LinearOperators.AbstractLinearOperator{Float64}} where M1<:Union{AbstractArray{Float64, 2}, LinearOperators.AbstractLinearOperator{Float64}} where S<:AbstractArray{Float64, 1}, RipQP.QM_IntData, RipQP.AbstractResiduals{Float64, S} where S, RipQP.StopCrit{Float64}, RipQP.DescentDirectionAllocs{Float64, S} where S, RipQP.PreallocatedDataK2LDL{Float64, _A, F, M} where M<:AbstractArray{Float64, 2} where F<:(RipQP.LDLFactorizationData{T} where T) where _A, RipQP.Tolerances{Float64}, RipQP.Counters, RipQP.InputConfig{Int64}, Bool}, sparams=svec(Float64, Float64), method=var"#iter!#116"(Bool, typeof(RipQP.iter!), RipQP.Point{T, S} where S, RipQP.IterData{T, S} where S, RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S, RipQP.QM_IntData, RipQP.AbstractResiduals{T, S} where S, RipQP.StopCrit{Tc}, RipQP.DescentDirectionAllocs{T, S} where S, RipQP.PreallocatedData{T, S} where S, RipQP.Tolerances{T}, RipQP.Counters, RipQP.InputConfig{I} where I<:Integer, Bool) where {T<:Real, Tc<:Real}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{RipQP.var"##update_regu_diagK2!#17", Bool, typeof(RipQP.update_regu_diagK2!), RipQP.Regularization{Float64}, LinearAlgebra.Symmetric{Float64, M} where M<:(SparseArrays.SparseMatrixCSC{Float64, Ti} where Ti<:Integer), Array{Int64, 1}, Float64, Int64, RipQP.Counters}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d610aa0)[Core.MethodMatch(spec_types=Tuple{RipQP.var"##update_regu_diagK2!#17", Bool, typeof(RipQP.update_regu_diagK2!), RipQP.Regularization{Float64}, LinearAlgebra.Symmetric{Float64, M} where M<:(SparseArrays.SparseMatrixCSC{Float64, Ti} where Ti<:Integer), Array{Int64, 1}, Float64, Int64, RipQP.Counters}, sparams=svec(Float64), method=var"#update_regu_diagK2!#17"(Bool, typeof(RipQP.update_regu_diagK2!), RipQP.Regularization{T}, LinearAlgebra.Symmetric{var"#s41", var"#s40"} where var"#s40"<:(SparseArrays.SparseMatrixCSC{Tv, Ti} where Ti<:Integer where Tv) where var"#s41"<:Real, Any, T, Int64, RipQP.Counters) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{NamedTuple{(:display, :sp), T} where T<:Tuple}, Tuple{Bool, RipQP.K2LDLParams{_A, RipQP.LDLFact} where _A}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228f009a60)[Core.MethodMatch(spec_types=Tuple{Type{NamedTuple{(:display, :sp), T} where T<:Tuple}, Tuple{Bool, RipQP.K2LDLParams{_A, RipQP.LDLFact} where _A}}, sparams=svec((:display, :sp)), 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.getproperty), Base.BitArray{N} where N, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742287ab6d20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.BitArray{N} where N, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Array{Int64, 1}, Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74228d567f60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Array{Int64, 1}, Int64}, sparams=svec(), method=getindex(Array{T, N} where N where T, Int64), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Array{Int64, 1}, Integer}, sparams=svec(), method=getindex(Array{T, N} where N where T, Integer, Integer...), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012d2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto_axcheck!), Array{Float64, 1}, Array{T, 1} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a7c9b900)[Core.MethodMatch(spec_types=Tuple{typeof(Base.copyto_axcheck!), Array{Float64, 1}, Array{T, 1} where T<:Real}, sparams=svec(), method=copyto_axcheck!(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012b7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.dict_with_eltype), Base.var"#Dict##0#Dict##1", Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A}, Type}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226ead2d20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.dict_with_eltype), Base.var"#Dict##0#Dict##1", Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A}, Union{Type{Pair{K, V}}, Type{Tuple{K, V}}}} where V where K, sparams=svec(K, V), method=dict_with_eltype(Any, Any, Union{Type{Pair{K, V}}, Type{Tuple{K, V}}}) where {K, V}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.dict_with_eltype), Base.var"#Dict##0#Dict##1", Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A}, Type}, sparams=svec(Base.var"#Dict##0#Dict##1"), method=dict_with_eltype(F, Any, Any) where {F}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000178a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{SolverTest.var"##unconstrained_nlp#28", Array{ADNLPModels.ADNLPModel{Float64, Array{Float64, 1}, Array{Int64, 1}}, 1}, Float64, Float64, typeof(SolverTest.unconstrained_nlp), Function}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422897c16e0)[Core.MethodMatch(spec_types=Tuple{SolverTest.var"##unconstrained_nlp#28", Array{ADNLPModels.ADNLPModel{Float64, Array{Float64, 1}, Array{Int64, 1}}, 1}, Float64, Float64, typeof(SolverTest.unconstrained_nlp), Function}, sparams=svec(), method=var"#unconstrained_nlp#28"(Any, Any, Any, typeof(SolverTest.unconstrained_nlp), Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976e, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.summary), Array{Tv, 1} where Tv<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a777ade0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.summary), Array{Tv, 1} where Tv<:Real}, sparams=svec(), method=summary(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004445, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), QuadraticModels.QuadraticModelPresolveData{T, S} where S where T<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228db96b20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), QuadraticModels.QuadraticModelPresolveData{T, S} where S where T<:Real, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{names, T} where T<:Tuple where names, Type{RipQP.RipQPDoubleSolver{T, S, I, QMType, Sd, Tsc, T1, S1, QMfd1, QMfd2, Pfd} where Pfd<:(RipQP.PreallocatedFloatData{T1, S1, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T1, S1} where Dda<:RipQP.DescentDirectionAllocs{T1, S1} where Res<:RipQP.AbstractResiduals{T1, S1}) where QMfd2<:(RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where QMfd1<:(RipQP.Abstract_QM_FloatData{T1, S1, M1, M2} where M2<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}} where M1<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}}) where S1 where T1 where Tsc<:Real where Sd<:RipQP.ScaleData{T, S} where QMType<:QuadraticModels.AbstractQuadraticModel{T, S} where I where S where T}, QuadraticModels.AbstractQuadraticModel{Float64, S} where S}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273af31a0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{names, T} where T<:Tuple where names, Type{RipQP.RipQPDoubleSolver{T, S, I, QMType, Sd, Tsc, T1, S1, QMfd1, QMfd2, Pfd} where Pfd<:(RipQP.PreallocatedFloatData{T1, S1, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T1, S1} where Dda<:RipQP.DescentDirectionAllocs{T1, S1} where Res<:RipQP.AbstractResiduals{T1, S1}) where QMfd2<:(RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where QMfd1<:(RipQP.Abstract_QM_FloatData{T1, S1, M1, M2} where M2<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}} where M1<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}}) where S1 where T1 where Tsc<:Real where Sd<:RipQP.ScaleData{T, S} where QMType<:QuadraticModels.AbstractQuadraticModel{T, S} where I where S where T}, QuadraticModels.AbstractQuadraticModel{Float64, S0}} where S0<:AbstractArray{Float64, 1}, sparams=svec(Float64, S0<:AbstractArray{Float64, 1}), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, Type{RipQP.RipQPDoubleSolver{T, S, I, QMType, Sd, Tsc, T1, S1, QMfd1, QMfd2, Pfd} where Pfd<:(RipQP.PreallocatedFloatData{T1, S1, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T1, S1} where Dda<:RipQP.DescentDirectionAllocs{T1, S1} where Res<:RipQP.AbstractResiduals{T1, S1}) where QMfd2<:(RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where QMfd1<:(RipQP.Abstract_QM_FloatData{T1, S1, M1, M2} where M2<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}} where M1<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}}) where S1 where T1 where Tsc<:Real where Sd<:RipQP.ScaleData{T, S} where QMType<:QuadraticModels.AbstractQuadraticModel{T, S} where I where S where T}, QuadraticModels.AbstractQuadraticModel{T0, S0}) where {T0<:Real, S0<:AbstractArray{T0, 1}}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{LinearOperators.LinearOperator{_A, Int64, F, Nothing, Nothing, T}} where T where F<:(RipQP.var"#PreconditionerData##14#PreconditionerData##15"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real) where _A, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##14#PreconditionerData##15"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real, Nothing, Nothing, Int64, Int64, Int64, Bool, Bool, Any, Any, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226cd0cd40)[Core.MethodMatch(spec_types=Tuple{Type{LinearOperators.LinearOperator{_A, Int64, F, Nothing, Nothing, T}} where T where F<:(RipQP.var"#PreconditionerData##14#PreconditionerData##15"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real) where _A, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##14#PreconditionerData##15"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real, Nothing, Nothing, Int64, Int64, Int64, Bool, Bool, Any, Any, Bool}, sparams=svec(), method=(::Type{LinearOperators.LinearOperator{T, I<:Integer, F, Ft, Fct, S}})(Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"##unsafe_wrap#63", Bool, typeof(Base.unsafe_wrap), Type{Array{T, N} where N where T}, Ptr{T} where T<:Union{Float32, Float64}, Tuple{UInt64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228c5d8920)[Core.MethodMatch(spec_types=Tuple{Base.var"##unsafe_wrap#63", Bool, typeof(Base.unsafe_wrap), Type{Array{T, N} where N where T}, Ptr{T} where T<:Union{Float32, Float64}, Tuple{UInt64}}, sparams=svec(T<:Union{Float32, Float64}, 1), method=var"#unsafe_wrap#63"(Bool, typeof(Base.unsafe_wrap), Union{Type{Array{T, N} where N where T}, Type{Array{T, N} where N}, Type{Array{T, N}}, Type{GenericMemory{kind, var"#s177", Core.AddrSpace{Core}(0x00)} where var"#s177"}, Type{GenericMemory{kind, T, Core.AddrSpace{Core}(0x00)}}} where kind, Ptr{T}, Tuple{Vararg{var"#s176", N}} where var"#s176"<:Integer) where {T, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c97, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.has_offset_axes), SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226f2fcaa0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.has_offset_axes), SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv}, sparams=svec(), method=has_offset_axes(Any), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000122f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, _A, var"#s179"} where var"#s179"<:Tuple where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7422889a99a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, _A, var"#s179"} where var"#s179"<:Tuple where _A}, sparams=svec(), method=instantiate(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004803, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Dict{Symbol, Union{Char, Integer, Tuple{Integer, Integer}}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a965e060)[Core.MethodMatch(spec_types=Tuple{Type{Base.Dict{Symbol, Union{Char, Integer, Tuple{Integer, Integer}}}}}, sparams=svec(Symbol, Union{Char, Integer, Tuple{Integer, Integer}}), method=(::Type{Base.Dict{K, V}})() where {K, V}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000034ae, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(+)), Number, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), AbstractArray{T, N} where N where T, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.abs), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R<:Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226ea2a3a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), AbstractArray{T, N} where N where T, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.abs), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R<:Real}}, sparams=svec(), method=materialize!(Any, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048be, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.haskey), Base.IdDict{Any, Any}, QuadraticModels.QPData{T, S, M1, M2} where M2<:(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv) where M1<:(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv) where S where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228f59dda0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.haskey), Base.IdDict{Any, Any}, QuadraticModels.QPData{T, S, M1, M2} where M2<:(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv) where M1<:(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv) where S where T<:Real}, sparams=svec(), method=haskey(Base.AbstractDict{K, V} where V where K, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000172a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Fix{1, F, T} where T where F}, Type{Base.MappingRF{F, T} where T where F}, typeof(LinearAlgebra.norm)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228dba27e0)[Core.MethodMatch(spec_types=Tuple{Type{Base.Fix{1, F, T} where T where F}, Type{Base.MappingRF{F, T} where T where F}, typeof(LinearAlgebra.norm)}, sparams=svec(1, UnionAll), method=(::Type{Base.Fix{N, F, T} where T where F})(F, Any) where {N, F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c46, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), Any, typeof(Base.:(>)), AbstractArray{Float64, 1}, AbstractArray{Float64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(6, 0x7422832ffea0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Base.Broadcast.DefaultArrayStyle{N} where N, typeof(Base.:(>)), FillArrays.AbstractFill{Float64, 1, Axes} where Axes, FillArrays.AbstractFill{Float64, 1, Axes} where Axes}, sparams=svec(), method=broadcasted(Base.Broadcast.DefaultArrayStyle{N} where N, Any, FillArrays.AbstractFill{T, N, Axes} where Axes where N where T, FillArrays.AbstractFill{T, N, Axes} where Axes where N where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Base.Broadcast.BroadcastStyle, typeof(Base.:(>)), AbstractArray{Float64, 1}, AbstractArray{Float64, 1}}, sparams=svec(typeof(Base.:(>))), method=broadcasted(Base.Broadcast.BroadcastStyle, F, Any...) where {F}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Any, typeof(Base.:(>)), AbstractArray{Float64, 1}, AbstractArray{Float64, 1}}, sparams=svec(F), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009681, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.set_ripqp_stats!), SolverCore.GenericExecutionStats{Float64, S, V, Tsp} where Tsp where V where S<:AbstractArray{Float64, 1}, RipQP.Point{T, S} where S where T<:Real, RipQP.AbstractResiduals{T, S} where S where T<:Real, RipQP.PreallocatedDataK2LDL{Float64, _A, F, M} where M<:AbstractArray{Float64, 2} where F<:(RipQP.LDLFactorizationData{T} where T) where _A, RipQP.IterData{T, S} where S where T<:Real, RipQP.QM_IntData, RipQP.StopCrit{Float64}, RipQP.Counters, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422887b4960)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.set_ripqp_stats!), SolverCore.GenericExecutionStats{Float64, S, V, Tsp} where Tsp where V where S<:AbstractArray{Float64, 1}, RipQP.Point{Float64, S} where S, RipQP.AbstractResiduals{Float64, S} where S, RipQP.PreallocatedDataK2LDL{Float64, _A, F, M} where M<:AbstractArray{Float64, 2} where F<:(RipQP.LDLFactorizationData{T} where T) where _A, RipQP.IterData{Float64, S} where S, RipQP.QM_IntData, RipQP.StopCrit{Float64}, RipQP.Counters, Int64}, sparams=svec(Float64), method=set_ripqp_stats!(SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T, RipQP.Point{T, S} where S, RipQP.AbstractResiduals{T, S} where S, RipQP.PreallocatedData{T, S} where S, RipQP.IterData{T, S} where S, RipQP.QM_IntData, RipQP.StopCrit{T} where T, RipQP.Counters, Int64) where {T}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Type{RipQP.PreallocatedDataK2LDL{T, _A, F, _B}} where _B<:AbstractArray{T, 2} where F<:(RipQP.LDLFactorizationData{T} where T) where _A where T<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742272ea2b20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Type{RipQP.PreallocatedDataK2LDL{T, _A, F, _B}} where _B<:AbstractArray{T, 2} where F<:(RipQP.LDLFactorizationData{T} where T) where _A where T<:Real, 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.:(*)), Any, Float64}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Array{Int64, 1}}, UndefInitializer, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core._typeof_captured_variable), Tuple{Array{Float64, 1}, AbstractArray{T, 1} where T}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a99c8e80)[Core.MethodMatch(spec_types=Tuple{typeof(Core._typeof_captured_variable), Tuple{Array{Float64, 1}, AbstractArray{T, 1} where T}}, sparams=svec(), method=_typeof_captured_variable(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000004a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), LinearAlgebra.Diagonal{Float64, S} where S<:AbstractArray{Float64, 1}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d29f700)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), LinearAlgebra.Diagonal{Float64, S} where S<:AbstractArray{Float64, 1}, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.maybeview), AbstractArray{T, 1} where T<:Real, Array{Int64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7422aa843920)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.maybeview), AbstractArray{T, 1} where T<:Real, Array{Int64, 1}}, sparams=svec(), method=maybeview(AbstractArray{T, N} where N where T, Any...), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002e4e, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.print_to_string), String, Type{Float64}, String, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422734d3f40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.print_to_string), String, Type{Float64}, String, String}, sparams=svec(), method=print_to_string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003dae, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.typeintersect), Type{Tuple{Any, Any}}, Type{var"#s175"} where var"#s175"<:Tuple{Float64, Base.SubArray{T, N, P, I, L} where L where I where P where N where T}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228dc55220)[Core.MethodMatch(spec_types=Tuple{typeof(Base.typeintersect), Type{Tuple{Any, Any}}, Type{var"#s175"} where var"#s175"<:Tuple{Float64, Base.SubArray{T, N, P, I, L} where L where I where P where N where T}}, sparams=svec(), method=typeintersect(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000527, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{RipQP.IterData{T, _A}} where _A where T<:Real, RipQP.IterData{T, S} where S where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226efe09e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{RipQP.IterData{T, S}}, RipQP.IterData{T0, S0}} where S0 where T0<:Real where S<:AbstractArray{T, 1} where T<:Real, sparams=svec(T<:Real, S<:AbstractArray{T<:Real, 1}, T0<:Real, S0), method=convert(Type{RipQP.IterData{T, S}}, RipQP.IterData{T0, S0}) where {T<:Real, S<:AbstractArray{T, 1}, T0<:Real, S0}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{RipQP.IterData{T, _A}}, RipQP.IterData{T, _A}} where T<:Real where _A, sparams=svec(T<:(RipQP.IterData{T, _A} where T<:Real where _A)), method=convert(Type{T}, T) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Ptr{Tv}} where Tv<:Union{Float16, Float32}, Ptr{Nothing}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228b144100)[Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Ptr{Tv}} where Tv<:Union{Float16, Float32}, Ptr{Nothing}}, sparams=svec(Tv<:Union{Float16, Float32}), 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(RipQP.update_pt_aff!), Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Float64, Float64, Array{Int64, 1}, Array{Int64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e520da0)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.update_pt_aff!), Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Float64, Float64, Array{Int64, 1}, Array{Int64, 1}}, sparams=svec(), method=update_pt_aff!(Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Array{Ti, 1} where Ti<:Integer, Int64} where var"#s175"<:Tuple{Array{Ti, 1} where Ti<:Integer, Int64}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422734a3b00)[Core.MethodMatch(spec_types=Tuple{Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Array{Ti, 1} where Ti<:Integer, Int64} where var"#s175"<:Tuple{Array{Ti, 1} where Ti<:Integer, Int64}, Int64}, sparams=svec(var"#s175"<:Tuple{Array{Ti, 1} where Ti<:Integer, Int64}), method=(::Base.var"#cvt1#convert##0"{T, x})(Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000376, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IndexStyle}, Type{Base.SubArray{Float64, 1, Array{Float64, 1}, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, false}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228c254a40)[Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Type{Base.SubArray{Float64, 1, Array{Float64, 1}, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, false}}}, sparams=svec(), method=(::Type{Base.IndexStyle})(Type{var"#s179"} where var"#s179"<:(AbstractArray{T, N} where N where T)), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000fa6, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Array{T, 1}} where T<:Number, UndefInitializer, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d7f96e0)[Core.MethodMatch(spec_types=Tuple{Type{Array{T, 1}} where T<:Number, UndefInitializer, Tuple{Int64}}, sparams=svec(T<:Number), 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{typeof(Base.getproperty), Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226eefa2a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), SparseArrays.ReadOnly{T, 2, V} where V<:AbstractArray{T, 2} where T<:Real, Symbol}, sparams=svec(), method=getproperty(SparseArrays.ReadOnly{T, N, V} where V<:AbstractArray{T, N} where N where T, Symbol), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T<:Real, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009675, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._push!), Array{ReverseDiff.AbstractInstruction, 1}, ReverseDiff.SpecialInstruction{typeof(Base.:(*)), I, O, C} where C<:Tuple{Any, Any} where O<:(ReverseDiff.TrackedArray{V, D, N, VA, DA} where DA where VA where N where D where V) where I<:Tuple{Any, ReverseDiff.TrackedArray{V, D, 1, VA, DA} where DA where VA where D where V}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226daa6840)[Core.MethodMatch(spec_types=Tuple{typeof(Base._push!), Array{ReverseDiff.AbstractInstruction, 1}, ReverseDiff.SpecialInstruction{typeof(Base.:(*)), I, O, C} where C<:Tuple{Any, Any} where O<:(ReverseDiff.TrackedArray{V, D, N, VA, DA} where DA where VA where N where D where V) where I<:Tuple{Any, ReverseDiff.TrackedArray{V, D, 1, VA, DA} where DA where VA where D where V}}, sparams=svec(ReverseDiff.AbstractInstruction), method=_push!(Array{T, 1}, T) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000113c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), Any, typeof(Base.:(-)), Any, FillArrays.Fill{Float64, 1, Tuple{Base.OneTo{Int64}}}}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.string), String, Type{T} where T<:(ReverseDiff.TrackedReal{V, D, O} where O where D<:Real where V<:Real), String, Type{ReverseDiff.TrackedReal{_A, _B, O}} where O<:(ReverseDiff.TrackedArray{V, D, 1, VA, DA} where V where D where VA where DA) where _B where _A, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a830bca0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.string), String, Type{T} where T<:(ReverseDiff.TrackedReal{V, D, O} where O where D<:Real where V<:Real), String, Type{ReverseDiff.TrackedReal{_A, _B, O}} where O<:(ReverseDiff.TrackedArray{V, D, 1, VA, DA} where V where D where VA where DA) where _B where _A, String}, sparams=svec(), method=string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003db1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{LinearOperators.var"##LinearOperator#14", Type{Array{T, 1}} where T<:Real, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, Type{T} where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##16#PreconditionerData##17"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Nothing, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a9a60ca0)[Core.MethodMatch(spec_types=Tuple{LinearOperators.var"##LinearOperator#14", Type{Array{T, 1}} where T<:Real, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, Type{T} where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##16#PreconditionerData##17"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Nothing, Nothing}, sparams=svec(T<:Real, Int64), method=var"#LinearOperator#14"(Any, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, Type{T}, I, I, Bool, Bool, Any, Any, Any) where {T, I<:Integer}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(-)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Ti, 1} where Ti<:Integer), Int64}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273477ce0)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(-)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Ti, 1} where Ti<:Integer), Int64}, 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(Core.kwcall), NamedTuple{(:own,), Tuple{Bool}}, typeof(Base.unsafe_wrap), Type{Array{T, N} where N where T}, Ptr{Float64}, Tuple{UInt64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422741edf20)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:own,), Tuple{Bool}}, typeof(Base.unsafe_wrap), Type{Array{T, N} where N where T}, Ptr{Float64}, Tuple{UInt64}}, sparams=svec(Float64, 1), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(Base.unsafe_wrap), Union{Type{Array{T, N} where N where T}, Type{Array{T, N} where N}, Type{Array{T, N}}, Type{GenericMemory{kind, var"#s173", Core.AddrSpace{Core}(0x00)} where var"#s173"}, Type{GenericMemory{kind, T, Core.AddrSpace{Core}(0x00)}}} where kind, Ptr{T}, Tuple{Vararg{var"#s172", N}} where var"#s172"<:Integer) where {T, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c99, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.to_indices), Base.SubArray{T, 2, P, I, L} where L where I where P where T, Tuple{Int64, Any}}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{Type{LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, T}} where T where F<:(RipQP.var"#PreconditionerData##6#PreconditionerData##7"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Int64, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Tf<:Real) where Tlow<:Real) where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##6#PreconditionerData##7"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Int64, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Tf<:Real) where Tlow<:Real, Nothing, Nothing, Int64, Int64, Int64, Bool, Bool, Any, Any, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a8532640)[Core.MethodMatch(spec_types=Tuple{Type{LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, T}} where T where F<:(RipQP.var"#PreconditionerData##6#PreconditionerData##7"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Int64, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Tf<:Real) where Tlow<:Real) where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##6#PreconditionerData##7"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Int64, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Tf<:Real) where Tlow<:Real, Nothing, Nothing, Int64, Int64, Int64, Bool, Bool, Any, Any, Bool}, sparams=svec(), method=(::Type{LinearOperators.LinearOperator{T, I<:Integer, F, Ft, Fct, S}})(Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T}, NLPModels.NLPModelMeta{Float64, Array{Float64, 1}}, NLPModels.Counters, ADNLPModels.ADModelBackend{_A, _B, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, _C, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend} where _C where _B where _A, SolverTest.var"#45#46", ADNLPModels.var"#301#302"{Type{Float64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d421a60)[Core.MethodMatch(spec_types=Tuple{Type{ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T}, NLPModels.NLPModelMeta{Float64, Array{Float64, 1}}, NLPModels.Counters, ADNLPModels.ADModelBackend{_A, _B, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, _C, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend} where _C where _B where _A, SolverTest.var"#45#46", ADNLPModels.var"#301#302"{Type{Float64}}}, sparams=svec(Float64, Array{Float64, 1}), method=(::Type{ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T})(NLPModels.NLPModelMeta{T, S}, NLPModels.Counters, ADNLPModels.ADModelBackend{GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS} where HBLS where JBLS where JtvBLS where JvBLS where HvBLS where GHJ where HB where JB where JtvB where JvB where HvB where GB, Any, Any) where {T, S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096b3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Array{Float64, 1}, AbstractArray{T, 1} where T} where var"#s175"<:Tuple{Array{Float64, 1}, AbstractArray{T, 1} where T}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a9a08680)[Core.MethodMatch(spec_types=Tuple{Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Array{Float64, 1}, AbstractArray{T, 1} where T} where var"#s175"<:Tuple{Array{Float64, 1}, AbstractArray{T, 1} where T}, Int64}, sparams=svec(var"#s175"<:Tuple{Array{Float64, 1}, AbstractArray{T, 1} where T}), method=(::Base.var"#cvt1#convert##0"{T, x})(Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000376, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), Base.Broadcast.DefaultArrayStyle{2}, typeof(SparseMatricesCOO.replace_if_minusinf), LinearAlgebra.Adjoint{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where Float64<:T<:Real, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7422878d9ae0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Base.Broadcast.DefaultArrayStyle{2}, typeof(SparseMatricesCOO.replace_if_minusinf), LinearAlgebra.Adjoint{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where Float64<:T<:Real, Int64}, sparams=svec(typeof(SparseMatricesCOO.replace_if_minusinf)), method=broadcasted(Base.Broadcast.BroadcastStyle, F, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000495a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(FillArrays._fill_getindex), FillArrays.AbstractFill{T, 1, Axes} where Axes where T, Array{Int64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228cb522a0)[Core.MethodMatch(spec_types=Tuple{typeof(FillArrays._fill_getindex), FillArrays.AbstractFill{T, 1, Axes} where Axes where T, Array{Int64, 1}}, sparams=svec(1), method=_fill_getindex(FillArrays.AbstractFill{T, N, Axes} where Axes where N where T, Vararg{Union{Real, AbstractArray{T, N} where N where T}, N}) where {N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009681, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Generator{I, F} where F where I}, Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##2#__cat_offset1!##3"{Tuple{Bool}, Tuple{Int64}, Array{Ti, 1}}} where Ti<:Integer, Base.UnitRange{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742284e55820)[Core.MethodMatch(spec_types=Tuple{Type{Base.Generator{I, F} where F where I}, Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##2#__cat_offset1!##3"{Tuple{Bool}, Tuple{Int64}, Array{Ti, 1}}} where Ti<:Integer, Base.UnitRange{Int64}}, sparams=svec(Base.UnitRange{Int64}, F<:(Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##2#__cat_offset1!##3"{Tuple{Bool}, Tuple{Int64}, Array{Ti, 1}}} where Ti<:Integer)), method=(::Type{Base.Generator{I, F} where F where I})(F, I) where {I, F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000420, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.throw_boundserror), Base.SubArray{T, 1, P, I, L} where L where I where P where T, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226dc11560)[Core.MethodMatch(spec_types=Tuple{typeof(Base.throw_boundserror), Base.SubArray{T, 1, P, I, L} where L where I where P where T, Tuple{Int64}}, sparams=svec(), method=throw_boundserror(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000310, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{UndefRefError}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742289b23340)[Core.MethodMatch(spec_types=Tuple{Type{UndefRefError}}, sparams=svec(), method=(::Type{UndefRefError})(), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000071, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Any, 1}}, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Int64, 1}}, Vararg{Pair{Symbol, _A} where _A, 4}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e376960)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Any, 1}}, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Int64, 1}}, Vararg{Pair{Symbol, _A} where _A, 4}}, Int64}, sparams=svec(), method=getindex(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000669, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.typeintersect), Type{Tuple{Any}}, Type{var"#s175"} where var"#s175"<:Tuple{AbstractArray{Float64, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d8579a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.typeintersect), Type{Tuple{Any}}, Type{var"#s175"} where var"#s175"<:Tuple{AbstractArray{Float64, 1}}}, sparams=svec(), method=typeintersect(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000527, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core._typeof_captured_variable), Tuple{Base.Broadcast.Extruded{FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Number)}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273bd4f40)[Core.MethodMatch(spec_types=Tuple{typeof(Core._typeof_captured_variable), Tuple{Base.Broadcast.Extruded{FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Number)}}, sparams=svec(), method=_typeof_captured_variable(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000004a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.cconvert), Type{Ptr{SparseArrays.LibSuiteSparse.cholmod_dense_struct}}, SparseArrays.CHOLMOD.Dense{Tv} where Tv<:Union{Float32, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226f09ffa0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.cconvert), Type{Ptr{SparseArrays.LibSuiteSparse.cholmod_dense_struct}}, SparseArrays.CHOLMOD.Dense{Tv} where Tv<:Union{Float32, Float64}}, 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.sqrt), Real}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{RipQP.var"##iter!#116", Bool, typeof(RipQP.iter!), RipQP.Point{Float64, S} where S<:AbstractArray{T, 1} where T<:Real, RipQP.IterData{Float64, S} where S, RipQP.QM_FloatData_ref{Float64, S, M1, M2} where M2<:Union{AbstractArray{Float64, 2}, LinearOperators.AbstractLinearOperator{Float64}} where M1<:Union{AbstractArray{Float64, 2}, LinearOperators.AbstractLinearOperator{Float64}} where S, RipQP.QM_IntData, RipQP.AbstractResiduals{Float64, S} where S, RipQP.StopCrit{Float64}, RipQP.DescentDirectionAllocs{Float64, S} where S, RipQP.PreallocatedDataK2LDL{Float64, _A, F, M} where M<:AbstractArray{Float64, 2} where F<:(RipQP.LDLFactorizationData{T} where T) where _A, RipQP.Tolerances{Float64}, RipQP.Counters, RipQP.InputConfig{Int64}, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e5a22c0)[Core.MethodMatch(spec_types=Tuple{RipQP.var"##iter!#116", Bool, typeof(RipQP.iter!), RipQP.Point{Float64, S} where S<:AbstractArray{T, 1} where T<:Real, RipQP.IterData{Float64, S} where S, RipQP.QM_FloatData_ref{Float64, S, M1, M2} where M2<:Union{AbstractArray{Float64, 2}, LinearOperators.AbstractLinearOperator{Float64}} where M1<:Union{AbstractArray{Float64, 2}, LinearOperators.AbstractLinearOperator{Float64}} where S, RipQP.QM_IntData, RipQP.AbstractResiduals{Float64, S} where S, RipQP.StopCrit{Float64}, RipQP.DescentDirectionAllocs{Float64, S} where S, RipQP.PreallocatedDataK2LDL{Float64, _A, F, M} where M<:AbstractArray{Float64, 2} where F<:(RipQP.LDLFactorizationData{T} where T) where _A, RipQP.Tolerances{Float64}, RipQP.Counters, RipQP.InputConfig{Int64}, Bool}, sparams=svec(Float64, Float64), method=var"#iter!#116"(Bool, typeof(RipQP.iter!), RipQP.Point{T, S} where S, RipQP.IterData{T, S} where S, RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S, RipQP.QM_IntData, RipQP.AbstractResiduals{T, S} where S, RipQP.StopCrit{Tc}, RipQP.DescentDirectionAllocs{T, S} where S, RipQP.PreallocatedData{T, S} where S, RipQP.Tolerances{T}, RipQP.Counters, RipQP.InputConfig{I} where I<:Integer, Bool) where {T<:Real, Tc<:Real}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{LinearOperators.var"##_#2", Type, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##16#PreconditionerData##17"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real, Nothing, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422730d8440)[Core.MethodMatch(spec_types=Tuple{LinearOperators.var"##_#2", Type, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##16#PreconditionerData##17"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real, Nothing, Nothing}, sparams=svec(T<:Real, Int64), method=var"#_#2"(Type, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, I, I, Bool, Bool, Any, Any, Any) where {T, I<:Integer}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.mightalias), Base.SubArray{_A, _B, P, I, true} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A, Array{_A, 1} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226f3521a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.mightalias), Base.SubArray{_A, _B, P, I, true} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A, Array{_A, 1} where _A}, sparams=svec(), method=mightalias(AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001312, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{ft} where ft<:Base.RefValue{typeof(Base.:(/))}, AbstractArray{T, N} where N where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742271bcc700)[Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, AbstractArray{T, N} where N where T}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000034c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{LinearOperators.var"##LinearOperator#14", Type{Array{Float64, 1}}, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, Type{Float64}, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##4#PreconditionerData##5"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real, Nothing, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a97c5760)[Core.MethodMatch(spec_types=Tuple{LinearOperators.var"##LinearOperator#14", Type{Array{Float64, 1}}, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, Type{Float64}, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##4#PreconditionerData##5"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real, Nothing, Nothing}, sparams=svec(Float64, Int64), method=var"#LinearOperator#14"(Any, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, Type{T}, I, I, Bool, Bool, Any, Any, Any) where {T, I<:Integer}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.get), SolverParameters.DefaultParameter{JSOSolvers.var"#83#84"}, ADNLPModels.ADNLPModel{T, V, Si} where Si where V<:AbstractArray{T, 1} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228f72ed00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.get), SolverParameters.DefaultParameter{JSOSolvers.var"#83#84"}, ADNLPModels.ADNLPModel{T, V, Si} where Si where V<:AbstractArray{T, 1} where T}, sparams=svec(), method=get(SolverParameters.DefaultParameter{Dflt} where Dflt, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096c7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Dict{K, V} where V where K}, Pair{Symbol, Nothing}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x742289fbdc20)[ Core.MethodMatch(spec_types=Tuple{Type{Base.Dict{K, V} where V where K}, Pair{Symbol, Nothing}}, sparams=svec(Symbol, Nothing), method=(::Type{Base.Dict{K, V} where V where K})(Pair{K, V}...) where {K, V}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000034b8, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.typeintersect), Type{Tuple{Any, Any}}, Type{var"#s175"} where var"#s175"<:Tuple{AbstractArray{Float64, 1}, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d57b400)[Core.MethodMatch(spec_types=Tuple{typeof(Base.typeintersect), Type{Tuple{Any, Any}}, Type{var"#s175"} where var"#s175"<:Tuple{AbstractArray{Float64, 1}, Float64}}, sparams=svec(), method=typeintersect(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000527, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), var"#s179"} where var"#s179"<:Tuple{Type}, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##10#PreconditionerData##11"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Nothing, Nothing, Int64, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74227165db40)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), var"#s179"} where var"#s179"<:Tuple{Type}, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##10#PreconditionerData##11"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Nothing, Nothing, Int64, Int64, Int64}, sparams=svec(T<:Real, Int64, F<:(RipQP.var"#PreconditionerData##10#PreconditionerData##11"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real), Nothing, Nothing), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, I, I, Bool, Bool, F, Ft, Fct, I, I, I) where {T, I<:Integer, F, Ft, Fct}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex_shape_check), Array{Ti, 1} where Ti<:Integer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74228b52d4e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex_shape_check), Array{Ti, 1} where Ti<:Integer, Int64}, sparams=svec(), method=setindex_shape_check(AbstractArray{var"#s179", 1} where var"#s179", Integer), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000fc6, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}, Any, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226de02f40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}, Any, Int64}, sparams=svec(Float64, 1), method=setindex!(FillArrays.AbstractFill{T, N, Axes} where Axes, Any, Vararg{Integer, N}) where {T, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009681, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), AbstractArray{T, 2} where T<:Float64, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226e945da0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), SparseArrays.ReadOnly{T, 2, V} where V<:AbstractArray{T, 2} where T<:Float64, Symbol}, sparams=svec(), method=getproperty(SparseArrays.ReadOnly{T, N, V} where V<:AbstractArray{T, N} where N where T, Symbol), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), AbstractArray{T, 2} where T<:Float64, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009675, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LinearAlgebra.isdiag), LinearAlgebra.Diagonal{T, V} where V<:Array{T, 1} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228f12ff80)[Core.MethodMatch(spec_types=Tuple{typeof(LinearAlgebra.isdiag), LinearAlgebra.Diagonal{T, V} where V<:Array{T, 1} where T<:Real}, sparams=svec(), method=isdiag(LinearAlgebra.Diagonal{var"#s4713", V} where V<:AbstractArray{var"#s4713", 1} where var"#s4713"<:Number), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000008b3a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.throw_boundserror), Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)} where var"#s179"<:Tuple, Tuple{Base.IteratorsMD.CartesianIndex{2}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742282e7a600)[Core.MethodMatch(spec_types=Tuple{typeof(Base.throw_boundserror), Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)} where var"#s179"<:Tuple, Tuple{Base.IteratorsMD.CartesianIndex{2}}}, sparams=svec(), method=throw_boundserror(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000310, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{DataStructures.ZippedSparseIntSetIterator{VT, IT} where IT where VT}, DataStructures.SparseIntSet, DataStructures.SparseIntSet}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742274262b20)[Core.MethodMatch(spec_types=Tuple{Type{DataStructures.ZippedSparseIntSetIterator{VT, IT} where IT where VT}, DataStructures.SparseIntSet, DataStructures.SparseIntSet}, sparams=svec(), method=(::Type{DataStructures.ZippedSparseIntSetIterator{VT, IT} where IT where VT})(DataStructures.SparseIntSet...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009733, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), Base.Dict{K, V} where V where K, QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2} where M2 where M1 where S where T, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x74226ee26860)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Base.Dict{K, Any}, QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2} where M2 where M1 where S where T, Symbol} where Symbol<:K<:Any, sparams=svec(Symbol<:K<:Any), method=setindex!(Base.Dict{K, Any}, Any, K) where {K}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Base.Dict{K, V}, QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2} where M2 where M1 where S where T, Symbol} where V where Symbol<:K<:Any, sparams=svec(Symbol<:K<:Any, V), method=setindex!(Base.Dict{K, V}, Any, K) where {K, V}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Base.Dict{K, V} where V where K, QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2} where M2 where M1 where S where T, Symbol}, sparams=svec(K, V), method=setindex!(Base.Dict{K, V}, Any, Any) where {K, V}, fully_covers=true), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000034da, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), typeof(SparseMatricesCOO.replace_if_minusinf), Array{T, 1} where T<:Real, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226ec729e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), typeof(SparseMatricesCOO.replace_if_minusinf), Array{T, 1} where T<:Real, Any}, sparams=svec(typeof(SparseMatricesCOO.replace_if_minusinf)), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004959, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.methods), RipQP.var"#PreconditionerData##4#PreconditionerData##5"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e14d5c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.methods), RipQP.var"#PreconditionerData##4#PreconditionerData##5"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}}, sparams=svec(), method=methods(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000057a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), LDLFactorizations.LDLFactorization{Tf, Int64, Int64, Int64} where Tf<:Number, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228950aa40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), LDLFactorizations.LDLFactorization{Tf, Int64, Int64, Int64} where Tf<:Number, Symbol}, sparams=svec(), method=getproperty(LDLFactorizations.LDLFactorization{T, Ti, Tn, Tp} where Tp<:Integer where Tn<:Integer where Ti<:Integer where T<:Number, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009767, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Float64}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(0,), mem=Memory{Any}(0, 0x7422b4033d90)[]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000000, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(FillArrays.Zeros{_A, 1, Tuple{Base.OneTo{Int64}}} where _A)}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742271545ee0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(FillArrays.Zeros{_A, 1, Tuple{Base.OneTo{Int64}}} where _A)}}, sparams=svec(), method=Typeof(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000028, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s179"} where var"#s179"<:Tuple{FillArrays.Fill{Float64, 1, Tuple{Base.OneTo{Int64}}}, Array{T, 1} where T<:Number}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d4dc360)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s179"} where var"#s179"<:Tuple{FillArrays.Fill{Float64, 1, Tuple{Base.OneTo{Int64}}}, Array{T, 1} where T<:Number}, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.diff_names), Tuple{Vararg{Symbol}}, Tuple{Symbol}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228a3e91c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.diff_names), Tuple{Vararg{Symbol}}, Tuple{Symbol}}, sparams=svec(), method=diff_names(Tuple{Vararg{Symbol}}, Tuple{Vararg{Symbol}}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001aaf, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Type{Base.RefValue{Ptr{SparseArrays.LibSuiteSparse.cholmod_factor_struct}}}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a79732a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Type{Base.RefValue{Ptr{SparseArrays.LibSuiteSparse.cholmod_factor_struct}}}, 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(Core._typeof_captured_variable), Tuple{Any, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273c38aa0)[Core.MethodMatch(spec_types=Tuple{typeof(Core._typeof_captured_variable), Tuple{Any, Float64}}, sparams=svec(), method=_typeof_captured_variable(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000004a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{SolverTools.TRONTrustRegion{T, V} where V where T}, Array{_A, 1} where _A, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d6569e0)[Core.MethodMatch(spec_types=Tuple{Type{SolverTools.TRONTrustRegion{T, V} where V where T}, Array{_A, 1} where _A, Any}, sparams=svec(T, V<:(Array{_A, 1} where _A)), method=(::Type{SolverTools.TRONTrustRegion{T, V} where V where T})(V, T) where {T, V}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096c0, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.string), String, Type{Int64}, String, Int32}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273705640)[Core.MethodMatch(spec_types=Tuple{typeof(Base.string), String, Type{Int64}, String, Int32}, sparams=svec(), method=string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003db1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isless), Any, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SolverCore.set_dual_residual!), SolverCore.GenericExecutionStats{T, V, V, Tsp} where Tsp where V where V<:AbstractArray{T, 1} where T, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a94873a0)[Core.MethodMatch(spec_types=Tuple{typeof(SolverCore.set_dual_residual!), SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp, Any} where V where S<:AbstractArray{T, 1} where T, sparams=svec(T, S, V), method=set_dual_residual!(SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp, T) where {T, S, V}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096bd, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SolverCore.eval_fun), ADNLPModels.ADNLPModel{T, V, Si} where Si where V<:AbstractArray{T, 1} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a9e3a280)[Core.MethodMatch(spec_types=Tuple{typeof(SolverCore.eval_fun), ADNLPModels.ADNLPModel{T, V, Si} where Si where V<:AbstractArray{T, 1} where T}, sparams=svec(), method=eval_fun(NLPModels.AbstractNLPModel{T, S} where S where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096bd, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SolverCore.set_status!), SolverCore.GenericExecutionStats{T, V, V, Tsp} where Tsp where V where V<:AbstractArray{T, 1} where T, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422aa062a00)[Core.MethodMatch(spec_types=Tuple{typeof(SolverCore.set_status!), SolverCore.GenericExecutionStats{T, V, V, Tsp} where Tsp where V where V<:AbstractArray{T, 1} where T, Symbol}, sparams=svec(), method=set_status!(SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096bd, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.BottomRF{typeof(Base.max)}, Any, Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226cde95a0)[ Core.MethodMatch(spec_types=Tuple{Base.BottomRF{typeof(Base.max)}, Base._InitialValue, Real}, sparams=svec(), method=(::Base.BottomRF{T})(Base._InitialValue, Any), fully_covers=false), Core.MethodMatch(spec_types=Tuple{Base.BottomRF{typeof(Base.max)}, Any, Real}, sparams=svec(), method=(::Base.BottomRF{T})(Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000031e6, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{LinearAlgebra.Adjoint{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T<:Real, Any}}, UInt64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226c43a360)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{LinearAlgebra.Adjoint{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T<:Real, Any}}, UInt64}, sparams=svec(), method=(::Type{MethodError})(Any, Any, UInt64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000009c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.OneTo{T} where T<:Integer}, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x742284f597e0)[ Core.MethodMatch(spec_types=Tuple{Type{Base.OneTo{T} where T<:Integer}, Base.AbstractRange{T}} where T<:Integer, sparams=svec(T<:Integer), method=(::Type{Base.OneTo{T} where T<:Integer})(Base.AbstractRange{T}) where {T<:Integer}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{Base.OneTo{T} where T<:Integer}, T} where T<:Integer, sparams=svec(T<:Integer), method=(::Type{Base.OneTo{T} where T<:Integer})(T) where {T<:Integer}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000008ab, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"##_#57", Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLPModel{T, S, Si}, Array{Int64, 1}, Int64}} where Si where S where T, Base.MappingRF{Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}, Base.BottomRF{typeof(Base.add_sum)}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422739e59c0)[Core.MethodMatch(spec_types=Tuple{Base.var"##_#57", Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLPModel{T, S, Si}, Array{Int64, 1}, Int64}} where Si where S where T, Base.MappingRF{Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}, Base.BottomRF{typeof(Base.add_sum)}}}, sparams=svec(), method=var"#_#57"(Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where T<:Tuple{Vararg{Any, N}} where names where N where V, Base.Fix{1, F, T} where T where F, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c4c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:(JSOSolvers.TRONParameterSet{_A} where _A), JSOSolvers.TRONParameterSet{T} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226f297860)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, JSOSolvers.TRONParameterSet{T} where T<:Real}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, JSOSolvers.TRONParameterSet{T} where T<:Real} where T<:(JSOSolvers.TRONParameterSet{_A} where _A), sparams=svec(T), method=convert(Type{T}, T) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000034c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.axes1), FillArrays.AbstractFill{Float64, 1, Axes} where Axes}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x742274856e20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.axes1), FillArrays.AbstractFill{Float64, 1, Axes} where Axes}, sparams=svec(), method=axes1(AbstractArray{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001237, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422712fd880)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Int64}, sparams=svec(1), method=getindex(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Vararg{Union{Integer, Base.IteratorsMD.CartesianIndex{N} where N}, N}) where {N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000487c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, Any, Tuple{Base.RefValue{typeof(Base.:(&))}, Any, Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x742289ca3da0)[ Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, Tuple, Tuple{Base.RefValue{typeof(Base.:(&))}, Any, Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}}, sparams=svec(), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, Tuple, Tuple), fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, Any, Tuple{Base.RefValue{typeof(Base.:(&))}, Any, Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}}, sparams=svec(F), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple) where {F}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:history, :scaling, :display, :mode), Tuple{Bool, Bool, Bool, Symbol}}, typeof(RipQP.RipQPSolver), QuadraticModels.QuadraticModel{T, S, M1, M2} where M2 where M1 where S where T, RipQP.RipQPDoubleParameters{Float64, RipQP.K2LDLParams{Float64, RipQP.LDLFact}, _A, RipQP.PC, RipQP.PC} where _A<:RipQP.SolverParams{Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273c39880)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:history, :scaling, :display, :mode), Tuple{Bool, Bool, Bool, Symbol}}, typeof(RipQP.RipQPSolver), QuadraticModels.QuadraticModel{Float64, S, M1, M2} where M2 where M1 where S, RipQP.RipQPDoubleParameters{Float64, RipQP.K2LDLParams{Float64, RipQP.LDLFact}, _A, RipQP.PC, RipQP.PC} where _A<:RipQP.SolverParams{Float64}}, sparams=svec(Float64), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(RipQP.RipQPSolver), QuadraticModels.AbstractQuadraticModel{T, S} where S, RipQP.RipQPDoubleParameters{T, SP1, SP2, SM1, SM2} where SM2<:RipQP.SolveMethod where SM1<:RipQP.SolveMethod where SP2<:RipQP.SolverParams{T} where SP1<:(RipQP.SolverParams{T} where T)) where {T}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core._typeof_captured_variable), Tuple{Any, Base.RefValue{T} where T, Vararg{Any}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742288b4ef60)[Core.MethodMatch(spec_types=Tuple{typeof(Core._typeof_captured_variable), Tuple{Any, Base.RefValue{T} where T, Vararg{Any}}}, sparams=svec(), method=_typeof_captured_variable(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000004a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), Nothing, typeof(RipQP.safe_boundary), Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74228428b6e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Nothing, typeof(RipQP.safe_boundary), Any}, sparams=svec(Nothing), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004959, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Pair{Symbol, _A} where _A, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a9a503e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Pair{Symbol, _A} where _A, Int64}, sparams=svec(), method=iterate(Pair{A, B} where B where A, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000007f3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.:(+)), Tuple{Array{Int64, 1}, Int64}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a9f24760)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.:(+)), Tuple{Array{Int64, 1}, Int64}, Nothing}, sparams=svec(typeof(Base.:(+))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.transpose), Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.min), Vararg{Any}}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._methods), RipQP.var"#PreconditionerData##8#PreconditionerData##9"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{T, Ti, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Ti<:Integer where T<:Real) where Tlow<:Real, Type{Tuple}, Int64, UInt64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228afb12e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._methods), RipQP.var"#PreconditionerData##8#PreconditionerData##9"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{T, Ti, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Ti<:Integer where T<:Real) where Tlow<:Real, Type{Tuple}, Int64, UInt64}, sparams=svec(), method=_methods(Any, Any, Int64, UInt64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000583, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), FillArrays.Zeros{Float64, 1, Axes} where Axes, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a7c9bdc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), FillArrays.Zeros{Float64, 1, Axes} where Axes, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.restart_copyto_nonleaf!), Array{_A, 1} where _A, Base.BitArray{1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(-)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Ti, 1} where Ti<:Integer), Int64}, Any, Int64, Base.OneTo{Int64}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422735681a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.restart_copyto_nonleaf!), Array{_A, 1} where _A, Base.BitArray{1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(-)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Ti, 1} where Ti<:Integer), Int64}, Any, Int64, Base.OneTo{Int64}, Int64, Int64}, sparams=svec(), method=restart_copyto_nonleaf!(Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048ef, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), AbstractArray{T, N} where N where T, Array{T, N} where N where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228c525400)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), AbstractArray{T, N} where N where T, Array{T, N} where N where T}, sparams=svec(), method=combine_styles(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004832, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{var"#s179", Nothing, typeof(RipQP.safe_boundary), var"#s179"} where var"#s179"<:Tuple{AbstractArray{T, 1} where T<:Real} where var"#s179"<:Base.Broadcast.BroadcastStyle, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742282f6b620)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{var"#s179", Nothing, typeof(RipQP.safe_boundary), var"#s179"} where var"#s179"<:Tuple{AbstractArray{T, 1} where T<:Real} where var"#s179"<:Base.Broadcast.BroadcastStyle, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.generic_factorize!), LinearAlgebra.Symmetric{Float64, S} where S<:(AbstractArray{var"#s4711", 2} where var"#s4711"<:Float64), RipQP.FactorizationData{T} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x74226e9741e0)[ Core.MethodMatch(spec_types=Tuple{typeof(RipQP.generic_factorize!), LinearAlgebra.Symmetric{Float64, S} where S<:(AbstractArray{var"#s4711", 2} where var"#s4711"<:Float64), RipQP.LDLFactorizationData{T} where T}, sparams=svec(), method=generic_factorize!(LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4711", 2} where var"#s4711"<:T) where T, RipQP.LDLFactorizationData{T} where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(RipQP.generic_factorize!), LinearAlgebra.Symmetric{Float64, S} where S<:(AbstractArray{var"#s4711", 2} where var"#s4711"<:Float64), RipQP.LLDLFactorizationData{T, F} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{T, Ti, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Ti<:Integer where T<:Real) where T}, sparams=svec(), method=generic_factorize!(LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4711", 2} where var"#s4711"<:T) where T, RipQP.LLDLFactorizationData{T, F} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{T, Ti, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Ti<:Integer where T<:Real) where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(RipQP.generic_factorize!), LinearAlgebra.Symmetric{Float64, SparseArrays.SparseMatrixCSC{Float64, Int64}}, RipQP.CholmodFactorization{Float64}}, sparams=svec(Float64), method=generic_factorize!(LinearAlgebra.Symmetric{T, SparseArrays.SparseMatrixCSC{T, Int64}}, RipQP.CholmodFactorization{T}) where {T}, fully_covers=false), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.LinearIndices{1, Tuple{Base.OneTo{Int64}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228a406c40)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.LinearIndices{1, Tuple{Base.OneTo{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(ADNLPModels.get_nln_nnzj), Any, Any, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Ref{T} where T}, typeof(Base.:(<=))}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742288400ba0)[Core.MethodMatch(spec_types=Tuple{Type{Ref{T} where T}, typeof(Base.:(<=))}, 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(OperatorScaling.get_norm_rc_CSC_sym!), AbstractArray{T, 1} where Float64<:T<:Real, Array{Int64, 1}, Array{Int64, 1}, Array{T, 1} where Float64<:T<:Real, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742283989c40)[Core.MethodMatch(spec_types=Tuple{typeof(OperatorScaling.get_norm_rc_CSC_sym!), AbstractArray{T, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{T, 1}, Int64} where Float64<:T<:Real, sparams=svec(Float64<:T<:Real), method=get_norm_rc_CSC_sym!(AbstractArray{T, 1}, Any, Any, AbstractArray{T, 1}, Any) where {T}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976c, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{LimitedLDLFactorizations.var"##lldl_factorize!#3", Any, typeof(LimitedLDLFactorizations.lldl_factorize!), LimitedLDLFactorizations.LimitedLDLFactorization{T, Ti, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Ti<:Integer where T<:Real, SparseArrays.SparseMatrixCSC{Tv, Ti} where Ti<:Integer where Tv<:Float64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228399ad00)[Core.MethodMatch(spec_types=Tuple{LimitedLDLFactorizations.var"##lldl_factorize!#3", Real, typeof(LimitedLDLFactorizations.lldl_factorize!), LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Ti, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T), SparseArrays.SparseMatrixCSC{Tv, Ti}} where Ti<:Integer where Tv<:Float64 where Tf<:Real, sparams=svec(Tf<:Number, Tv<:Number, Ti<:Integer), method=var"#lldl_factorize!#3"(Tf, typeof(LimitedLDLFactorizations.lldl_factorize!), LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Ti, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T), SparseArrays.SparseMatrixCSC{Tv, Ti}) where {Tf<:Number, Tv<:Number, Ti<:Integer}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009769, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{RipQP.StopCrit{Float64}, RipQP.QM_FloatData{Float64, S, _A, _B} where _B where _A where S<:AbstractArray{Float64, 1}, RipQP.QM_IntData, RipQP.Tolerances{Float64}, Union{RipQP.Residuals{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T<:Real where T<:Real, RipQP.ResidualsHistory{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T<:Real where T<:Real}, Union{RipQP.IterDataCPU{Float64, _A} where _A, RipQP.IterDataGPU{Float64, _A} where _A}, RipQP.Point{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T<:Real where T<:Real, Union{RipQP.ScaleDataLP{Float64, S} where S<:AbstractArray{Float64, 1}, RipQP.ScaleDataQP{Float64, S} where S<:AbstractArray{Float64, 1}}, RipQP.StartingPointData{Float64, _A} where _A, RipQP.Counters}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228db5dfe0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{RipQP.StopCrit{Float64}, RipQP.QM_FloatData{Float64, S, _A, _B} where _B where _A where S<:AbstractArray{Float64, 1}, RipQP.QM_IntData, RipQP.Tolerances{Float64}, Union{RipQP.Residuals{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T<:Real where T<:Real, RipQP.ResidualsHistory{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T<:Real where T<:Real}, Union{RipQP.IterDataCPU{Float64, _A} where _A, RipQP.IterDataGPU{Float64, _A} where _A}, RipQP.Point{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T<:Real where T<:Real, Union{RipQP.ScaleDataLP{Float64, S} where S<:AbstractArray{Float64, 1}, RipQP.ScaleDataQP{Float64, S} where S<:AbstractArray{Float64, 1}}, RipQP.StartingPointData{Float64, _A} where _A, RipQP.Counters}, Int64, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000689, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.string), String, Type{S} where S<:(Base.Broadcast.DefaultArrayStyle{N} where N), String, Type{Base.Broadcast.DefaultArrayStyle{1}}, String, Type{U} where U<:(Base.Broadcast.DefaultArrayStyle{N} where N), String, Type{Base.Broadcast.DefaultArrayStyle{1}}, String, Type{S} where S<:(Base.Broadcast.DefaultArrayStyle{N} where N), String, Type{V} where V<:(Base.Broadcast.DefaultArrayStyle{N} where N), String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422aa7617a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.string), String, Type{S} where S<:(Base.Broadcast.DefaultArrayStyle{N} where N), String, Type{Base.Broadcast.DefaultArrayStyle{1}}, String, Type{U} where U<:(Base.Broadcast.DefaultArrayStyle{N} where N), String, Type{Base.Broadcast.DefaultArrayStyle{1}}, String, Type{S} where S<:(Base.Broadcast.DefaultArrayStyle{N} where N), String, Type{V} where V<:(Base.Broadcast.DefaultArrayStyle{N} where N), String}, sparams=svec(), method=string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003db1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._setindex!), Base.IndexLinear, Array{Int64, 1}, Int64, Vararg{Any}}, limit=3), nothing, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._similar_shape), Base.Generator{Base.UnitRange{Int64}, F} where F<:(Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##0#__cat_offset1!##1"{var"#s179", Tuple{Bool, Bool}, Tuple{Vararg{Int64, N}}, _A}} where _A where N where var"#s179"<:Tuple{Any, Any, Vararg{Int64}}), Base.HasShape{1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e5c8b00)[Core.MethodMatch(spec_types=Tuple{typeof(Base._similar_shape), Base.Generator{Base.UnitRange{Int64}, F} where F<:(Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##0#__cat_offset1!##1"{var"#s179", Tuple{Bool, Bool}, Tuple{Vararg{Int64, N}}, _A}} where _A where N where var"#s179"<:Tuple{Any, Any, Vararg{Int64}}), Base.HasShape{1}}, sparams=svec(), method=_similar_shape(Any, Base.HasShape{N} where N), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010ea, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(FillArrays.broadcasted_fill), typeof(SparseMatricesCOO.replace_if_minusinf), FillArrays.Fill{T, 1, Axes} where Axes where Float64<:T<:Real, Float64, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742283795380)[Core.MethodMatch(spec_types=Tuple{typeof(FillArrays.broadcasted_fill), typeof(SparseMatricesCOO.replace_if_minusinf), FillArrays.Fill{T, 1, Axes} where Axes where Float64<:T<:Real, Float64, Any}, sparams=svec(), method=broadcasted_fill(Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009681, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Ref{T} where T}, Ptr{SparseArrays.LibSuiteSparse.cholmod_factor_struct}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a78ba3e0)[Core.MethodMatch(spec_types=Tuple{Type{Ref{T} where T}, Ptr{SparseArrays.LibSuiteSparse.cholmod_factor_struct}}, 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{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Nothing, typeof(Base.:(*)), Tuple{Int64, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273bfed40)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Nothing, typeof(Base.:(*)), Tuple{Int64, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Tuple{Base.OneTo{Int64}}}, sparams=svec(typeof(Base.:(*))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eltype), Type{LinearAlgebra.Diagonal{T, V}} where V<:Array{T, 1} where T<:Real}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226ebdd1e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.eltype), Type{LinearAlgebra.Diagonal{T, V}} where V<:Array{T, 1} where T<:Real}, sparams=svec(T<:Real), method=eltype(Type{var"#s179"} where var"#s179"<:(AbstractArray{E, N} where N)) where {E}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001247, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._setindex!), Base.Dict{K, Any} where K, QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2} where M2 where M1 where S where T, Any, Int64, UInt8}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226df44280)[Core.MethodMatch(spec_types=Tuple{typeof(Base._setindex!), Base.Dict{K, Any} where K, QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2} where M2 where M1 where S where T, Any, Int64, UInt8}, sparams=svec(), method=_setindex!(Base.Dict{K, V} where V where K, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000034d7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{LinearOperators.LinearOperator{T, Int64, F, Ft, Fct, _A}} where _A where Fct<:(LinearOperators.var"#*##4#*##5"{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}, LinearOperators.AdjointLinearOperator{T, S}, _A} where _A where S where T where S where Fct where Ft where F where I<:Integer where T) where Ft<:(LinearOperators.var"#*##2#*##3"{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}, LinearOperators.AdjointLinearOperator{T, S}, _A} where _A where S where T where S where Fct where Ft where F where I<:Integer where T) where F<:(LinearOperators.var"#*##0#*##1"{LinearOperators.AdjointLinearOperator{T, S}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}, _A} where _A where S where Fct where Ft where F where I<:Integer where T where S where T) where T, Int64, Int64, Bool, Bool, LinearOperators.var"#*##0#*##1"{LinearOperators.AdjointLinearOperator{T, S}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}, _A} where _A where S where Fct where Ft where F where I<:Integer where T where S where T, LinearOperators.var"#*##2#*##3"{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}, LinearOperators.AdjointLinearOperator{T, S}, _A} where _A where S where T where S where Fct where Ft where F where I<:Integer where T, LinearOperators.var"#*##4#*##5"{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}, LinearOperators.AdjointLinearOperator{T, S}, _A} where _A where S where T where S where Fct where Ft where F where I<:Integer where T, Int64, Int64, Int64, Bool, Bool, Any, Any, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d59c860)[Core.MethodMatch(spec_types=Tuple{Type{LinearOperators.LinearOperator{T, Int64, F, Ft, Fct, _A}} where _A where Fct<:(LinearOperators.var"#*##4#*##5"{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}, LinearOperators.AdjointLinearOperator{T, S}, _A} where _A where S where T where S where Fct where Ft where F where I<:Integer where T) where Ft<:(LinearOperators.var"#*##2#*##3"{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}, LinearOperators.AdjointLinearOperator{T, S}, _A} where _A where S where T where S where Fct where Ft where F where I<:Integer where T) where F<:(LinearOperators.var"#*##0#*##1"{LinearOperators.AdjointLinearOperator{T, S}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}, _A} where _A where S where Fct where Ft where F where I<:Integer where T where S where T) where T, Int64, Int64, Bool, Bool, LinearOperators.var"#*##0#*##1"{LinearOperators.AdjointLinearOperator{T, S}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}, _A} where _A where S where Fct where Ft where F where I<:Integer where T where S where T, LinearOperators.var"#*##2#*##3"{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}, LinearOperators.AdjointLinearOperator{T, S}, _A} where _A where S where T where S where Fct where Ft where F where I<:Integer where T, LinearOperators.var"#*##4#*##5"{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}, LinearOperators.AdjointLinearOperator{T, S}, _A} where _A where S where T where S where Fct where Ft where F where I<:Integer where T, Int64, Int64, Int64, Bool, Bool, Any, Any, Bool}, sparams=svec(), method=(::Type{LinearOperators.LinearOperator{T, I<:Integer, F, Ft, Fct, S}})(Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Type{S0} where S0<:(Array{T, 1} where T<:Real), Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226e24e6e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Type{S0} where S0<:(Array{T, 1} where T<:Real), 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{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, Type{T} where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Int64, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Tf<:Real) where Tlow<:Real, Nothing, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a70f8020)[Core.MethodMatch(spec_types=Tuple{Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, Type{T} where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Int64, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Tf<:Real) where Tlow<:Real, Nothing, Nothing}, sparams=svec(T<:Real, Int64), method=(::Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T})(Type{T}, I, I, Bool, Bool, Any, Any, Any) where {T, I<:Integer}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.pointer), Array{Tv, 1} where Tv<:Union{Float16, Float32}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226c2055a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.pointer), Array{Tv, 1} where Tv<:Union{Float16, Float32}}, sparams=svec(Tv<:Union{Float16, Float32}), method=pointer(AbstractArray{T, N} where N) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012c9, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Iterators._zip_iterate_interleave), Tuple{Any}, Tuple{}, Tuple{Base.Missing}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228ce20b40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators._zip_iterate_interleave), Tuple{Any}, Tuple{}, Tuple{Base.Missing}}, sparams=svec(), method=_zip_iterate_interleave(Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000018ca, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{Any, Tuple{Int64}}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742283e5f720)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{Any, Tuple{Int64}}, Int64, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000689, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(6, 0x74226f4c77c0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), Union{}}, Int64}, sparams=svec(T, S), method=_broadcast_getindex(Base.Broadcast.Broadcasted{var"#s677", var"#s676", var"#s675", var"#s674"} where var"#s674"<:Tuple{Ref{Type{T}}, Ref{Type{S}}, Vararg{Any}} where var"#s675" where var"#s676" where var"#s677", Any) where {T, S}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Int64}, sparams=svec(), method=_broadcast_getindex(Base.Broadcast.Broadcasted{var"#s677", var"#s676", var"#s675", var"#s674"} where var"#s674" where var"#s675" where var"#s676" where var"#s677", Any), fully_covers=true), #, #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004899, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{ADNLPModels.ADModelBackend{GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS} where HBLS where JBLS where JtvBLS where JvBLS where HvBLS where GHJ where HB where JB where JtvB where JvB where HvB where GB}, Any, Any, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, Any, Vararg{ADNLPModels.EmptyADbackend, 6}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228cc4ca00)[Core.MethodMatch(spec_types=Tuple{Type{ADNLPModels.ADModelBackend{GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS} where HBLS where JBLS where JtvBLS where JvBLS where HvBLS where GHJ where HB where JB where JtvB where JvB where HvB where GB}, Any, Any, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, Any, Vararg{ADNLPModels.EmptyADbackend, 6}}, sparams=svec(GB, HvB, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, HB, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend), method=(::Type{ADNLPModels.ADModelBackend{GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS} where HBLS where JBLS where JtvBLS where JvBLS where HvBLS where GHJ where HB where JB where JtvB where JvB where HvB where GB})(GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS) where {GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096b3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(var"==")), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Int64, Base.IteratorsMD.CartesianIndex{0}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d1334e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(var"==")), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Int64, Base.IteratorsMD.CartesianIndex{0}}, sparams=svec(2), method=getindex(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Vararg{Union{Integer, Base.IteratorsMD.CartesianIndex{N} where N}, N}) where {N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000487c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{T} where T<:(Base.Complex{T} where T<:Union{Float32, Float64}), Base.Complex{T} where T<:Union{Float32, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x74226ee12c60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Base.Complex{T} where T<:Union{Float32, Float64}}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, Base.Complex{T} where T<:Union{Float32, Float64}} where T<:(Base.Complex{T} where T<:Union{Float32, Float64}), sparams=svec(T<:Number), method=convert(Type{T}, T) where {T<:Number}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T} where T<:(Base.Complex{T} where T<:Union{Float32, Float64}), Base.Complex{T} where T<:Union{Float32, Float64}}, sparams=svec(T<:(Base.Complex{T} where T<:Union{Float32, Float64})), 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.unwrap_composed), Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLPModel{T, S, Si}, Array{Int64, 1}, Int64}} where Si where S where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228b8c75a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unwrap_composed), Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLPModel{T, S, Si}, Array{Int64, 1}, Int64}} where Si where S where T}, sparams=svec(), method=unwrap_composed(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c2a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"##invokelatest_gr#232", Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest_gr), GlobalRef, Any, Symbol, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422862d4aa0)[Core.MethodMatch(spec_types=Tuple{Base.var"##invokelatest_gr#232", Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.invokelatest_gr), GlobalRef, Any, Symbol, Bool}, sparams=svec(), method=var"#invokelatest_gr#232"(Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where T<:Tuple{Vararg{Any, N}} where names where N where V, typeof(Base.invokelatest_gr), GlobalRef, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002d33, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{RipQP.RipQPMonoParameters{T, SP1, SM1} where SM1<:RipQP.SolveMethod where SP1<:RipQP.SolverParams{T}} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228c016840)[Core.MethodMatch(spec_types=Tuple{Type{RipQP.RipQPMonoParameters{T, SP1, SM1} where SM1<:RipQP.SolveMethod where SP1<:RipQP.SolverParams{T}} where T<:Real}, sparams=svec(T<:Real), method=(::Type{RipQP.RipQPMonoParameters{T, SP1, SM1} where SM1<:RipQP.SolveMethod where SP1<:RipQP.SolverParams{T}})() where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{ADNLPModels.var"##ADNLPModel#306", Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, Type{ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T}, SolverTest.var"#f#98", SolverTest.var"#c2#100"{SolverTest.var"#c#99"}, Array{_A, 1} where _A, Any, SolverTest.var"#c2#100"{SolverTest.var"#c#99"}, SolverTest.var"#c2#100"{SolverTest.var"#c#99"}, SolverTest.var"#c2#100"{SolverTest.var"#c#99"}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422732b3180)[Core.MethodMatch(spec_types=Tuple{ADNLPModels.var"##ADNLPModel#306", Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, Type{ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T}, SolverTest.var"#f#98", SolverTest.var"#c2#100"{SolverTest.var"#c#99"}, Array{_A, 1} where _A, Any, SolverTest.var"#c2#100"{SolverTest.var"#c#99"}, SolverTest.var"#c2#100"{SolverTest.var"#c#99"}, SolverTest.var"#c2#100"{SolverTest.var"#c#99"}}, sparams=svec(SolverTest.var"#c2#100"{SolverTest.var"#c#99"}), method=var"#ADNLPModel#306"(Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where T<:Tuple{Vararg{Any, N}} where names where N where V, Type{ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T}, Any, S, Any, Any, S, S, S) where {S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096b3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), RipQP.InputTol{T, Int64} where T<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226cae7260)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), RipQP.InputTol{T, Int64} where T<:Real, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{NLPModels.DimensionError}, String, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228db94480)[Core.MethodMatch(spec_types=Tuple{Type{NLPModels.DimensionError}, String, Int64, Int64}, sparams=svec(), method=(::Type{NLPModels.DimensionError})(Union{String, Symbol}, Int64, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096b0, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"##open#330", Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.open), Function, String, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a6ef2600)[Core.MethodMatch(spec_types=Tuple{Base.var"##open#330", Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(Base.open), Function, String, String}, sparams=svec(), method=var"#open#330"(Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where T<:Tuple{Vararg{Any, N}} where names where N where V, typeof(Base.open), Function, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000037ef, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:x0,), Tuple{Array{Float64, 1}}}, Type{ADNLPModels.ADModelBackend{GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS} where HBLS where JBLS where JtvBLS where JvBLS where HvBLS where GHJ where HB where JB where JtvB where JvB where HvB where GB}, Int64, SolverTest.var"#22#23"}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228bbe5780)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:x0,), Tuple{Array{Float64, 1}}}, Type{ADNLPModels.ADModelBackend{GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS} where HBLS where JBLS where JtvBLS where JvBLS where HvBLS where GHJ where HB where JB where JtvB where JvB where HvB where GB}, Int64, SolverTest.var"#22#23"}, sparams=svec(), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, Type{ADNLPModels.ADModelBackend{GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS} where HBLS where JBLS where JtvBLS where JvBLS where HvBLS where GHJ where HB where JB where JtvB where JvB where HvB where GB}, Integer, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096b3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{NLPModels.var"##_#43", Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Type{NLPModels.NLPModelMeta{Float64, Array{Float64, 1}}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e23bea0)[Core.MethodMatch(spec_types=Tuple{NLPModels.var"##_#43", Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Any, Any, Any, Any, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Any, Any, Any, Any, Any, Any, Any, Any, Any, Type{NLPModels.NLPModelMeta{Float64, Array{Float64, 1}}}, Int64}, sparams=svec(Float64, Array{Float64, 1}), method=var"#_#43"(S, S, S, Any, Any, Any, Any, S, S, S, Any, Any, Any, Any, Any, Any, Any, Any, Any, Type{NLPModels.NLPModelMeta{T, S}}, Int64) where {T, S}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096b0, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eachindex), Base.IndexLinear, Base.ReshapedArray{T, N, A, Tuple{}} where A<:(Base.AbstractRange{T} where T) where N where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x742284f74e20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), Base.IndexLinear, Base.ReshapedArray{T, 1, A, Tuple{}} where A<:(Base.AbstractRange{T} where T) where T}, sparams=svec(), method=eachindex(Base.IndexLinear, AbstractArray{T, 1} where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), Base.IndexLinear, Base.ReshapedArray{T, N, A, Tuple{}} where A<:(Base.AbstractRange{T} where T) where N where T}, sparams=svec(), method=eachindex(Base.IndexLinear, AbstractArray{T, N} where N where T), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001257, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Tuple{typeof(DataType), Type}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422731e0f20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Tuple{typeof(DataType), Type}}, sparams=svec(), method=iterate(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000067a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(+)), Int64, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x742289696ea0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(+)), Int64, Any}, sparams=svec(typeof(Base.:(+))), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004959, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.allocatedinline), Type{Ptr{SparseArrays.LibSuiteSparse.cholmod_dense_struct}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a94b88e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.allocatedinline), Type{Ptr{SparseArrays.LibSuiteSparse.cholmod_dense_struct}}}, 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{typeof(Base._methods), RipQP.var"#PreconditionerData##6#PreconditionerData##7"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Int64, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Tf<:Real) where Tlow<:Real, Type{Tuple}, Int64, UInt64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a9087ce0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._methods), RipQP.var"#PreconditionerData##6#PreconditionerData##7"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Int64, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Tf<:Real) where Tlow<:Real, Type{Tuple}, Int64, UInt64}, sparams=svec(), method=_methods(Any, Any, Int64, UInt64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000583, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.zero), Type{Float16}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742287ab42a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.zero), Type{Float16}}, sparams=svec(Float16), 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(Core.kwcall), NamedTuple{(:S,), var"#s179"} where var"#s179"<:Tuple{Any}, typeof(LinearOperators.CompositeLinearOperator), Any, Any, Any, Union{Base.Missing, Bool}, Union{Base.Missing, Bool}, LinearOperators.var"#prod!#138"{var"#s179"} where var"#s179"<:Tuple{Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T, LinearOperators.LinearOperator{_A, Int64, LinearOperators.var"#119#120", LinearOperators.var"#119#120", LinearOperators.var"#119#120", T} where T where _A}, LinearOperators.var"#tprod!#139"{var"#s179"} where var"#s179"<:Tuple{Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T, LinearOperators.LinearOperator{_A, Int64, LinearOperators.var"#119#120", LinearOperators.var"#119#120", LinearOperators.var"#119#120", T} where T where _A}, LinearOperators.var"#ctprod!#140"{var"#s179"} where var"#s179"<:Tuple{Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T, LinearOperators.LinearOperator{_A, Int64, LinearOperators.var"#119#120", LinearOperators.var"#119#120", LinearOperators.var"#119#120", T} where T where _A}, Union{Base.Missing, Bool}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a858dae0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), var"#s179"} where var"#s179"<:Tuple{Any}, typeof(LinearOperators.CompositeLinearOperator), Type, I, I, Bool, Bool, F, Ft, Fct, Bool} where Fct<:(LinearOperators.var"#ctprod!#140"{var"#s179"} where var"#s179"<:Tuple{Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T, LinearOperators.LinearOperator{_A, Int64, LinearOperators.var"#119#120", LinearOperators.var"#119#120", LinearOperators.var"#119#120", T} where T where _A}) where Ft<:(LinearOperators.var"#tprod!#139"{var"#s179"} where var"#s179"<:Tuple{Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T, LinearOperators.LinearOperator{_A, Int64, LinearOperators.var"#119#120", LinearOperators.var"#119#120", LinearOperators.var"#119#120", T} where T where _A}) where F<:(LinearOperators.var"#prod!#138"{var"#s179"} where var"#s179"<:Tuple{Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T, LinearOperators.LinearOperator{_A, Int64, LinearOperators.var"#119#120", LinearOperators.var"#119#120", LinearOperators.var"#119#120", T} where T where _A}) where I<:Integer, sparams=svec(I<:I<:Integer, F<:F<:(LinearOperators.var"#prod!#138"{var"#s179"} where var"#s179"<:Tuple{Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T, LinearOperators.LinearOperator{_A, Int64, LinearOperators.var"#119#120", LinearOperators.var"#119#120", LinearOperators.var"#119#120", T} where T where _A}), Ft<:Ft<:(LinearOperators.var"#tprod!#139"{var"#s179"} where var"#s179"<:Tuple{Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T, LinearOperators.LinearOperator{_A, Int64, LinearOperators.var"#119#120", LinearOperators.var"#119#120", LinearOperators.var"#119#120", T} where T where _A}), Fct<:Fct<:(LinearOperators.var"#ctprod!#140"{var"#s179"} where var"#s179"<:Tuple{Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T, LinearOperators.LinearOperator{_A, Int64, LinearOperators.var"#119#120", LinearOperators.var"#119#120", LinearOperators.var"#119#120", T} where T where _A})), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(LinearOperators.CompositeLinearOperator), Type, I, I, Bool, Bool, F, Ft, Fct, Bool) where {I<:Integer, F, Ft, Fct}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.zero), Type{UInt64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742287d54ac0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.zero), Type{UInt64}}, sparams=svec(UInt64), 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.similar), LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4711", 2} where var"#s4711"<:T) where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226f2533a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4711", 2} where var"#s4711"<:T) where T}, sparams=svec(T), method=similar(AbstractArray{T, N} where N) where {T}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000128c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseArrays.nonzeros), SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv<:Number}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273ad62c0)[Core.MethodMatch(spec_types=Tuple{typeof(SparseArrays.nonzeros), SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv<:Number}, sparams=svec(), method=nonzeros(Union{SparseArrays.FixedSparseCSC{Tv, Ti} where Ti<:Integer where Tv, SparseArrays.SparseMatrixCSC{Tv, Ti} where Ti<:Integer where Tv}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009675, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.tagcount), Type{ForwardDiff.Tag{_A, V}} where V where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a966dfe0)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.tagcount), Type{ForwardDiff.Tag{_A, V}} where V where _A}, sparams=svec(_A, V), method=tagcount(Type{ForwardDiff.Tag{F, V}}) where {F, V}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009697, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(*)), FillArrays.Zeros{Float64, 1, Tuple{Base.OneTo{Int64}}}, AbstractArray{Float64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x742288937fa0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(*)), FillArrays.Zeros{Float64, 1, Tuple{Base.OneTo{Int64}}}, AbstractArray{Float64, 1}}, sparams=svec(typeof(Base.:(*))), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004959, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, T}} where T where F<:(RipQP.var"#PreconditionerData##4#PreconditionerData##5"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}) where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##4#PreconditionerData##5"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}, Nothing, Nothing, Int64, Int64, Int64, Bool, Bool, Any, Any, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e2a5360)[Core.MethodMatch(spec_types=Tuple{Type{LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, T}} where T where F<:(RipQP.var"#PreconditionerData##4#PreconditionerData##5"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}) where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##4#PreconditionerData##5"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}, Nothing, Nothing, Int64, Int64, Int64, Bool, Bool, Any, Any, Bool}, sparams=svec(), method=(::Type{LinearOperators.LinearOperator{T, I<:Integer, F, Ft, Fct, S}})(Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.IteratorsMD.CartesianIndex{N} where N, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742283dc39e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.IteratorsMD.CartesianIndex{N} where N, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Tf} where Tf<:Number, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.throwdm), Tuple, Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742270f51ee0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.throwdm), Tuple, Tuple}, sparams=svec(), method=throwdm(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048ed, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(FillArrays._fill_getindex), FillArrays.AbstractFill{T, N, Axes} where Axes where N where T, Array{Int64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742284884940)[Core.MethodMatch(spec_types=Tuple{typeof(FillArrays._fill_getindex), FillArrays.AbstractFill{T, N, Axes} where Axes where N where T, Array{Int64, 1}}, sparams=svec(1), method=_fill_getindex(FillArrays.AbstractFill{T, N, Axes} where Axes where N where T, Vararg{Union{Real, AbstractArray{T, N} where N where T}, N}) where {N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009681, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IndexStyle}, Array{Float32, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226f017ee0)[ Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Array{Float32, 1}}, sparams=svec(), method=(::Type{Base.IndexStyle})(AbstractArray{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000fa4, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), SparseMatricesCOO.SparseMatrixCOO{Float64, Ti} where Ti<:Integer, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e5eaf40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), SparseMatricesCOO.SparseMatrixCOO{Float64, Ti} where Ti<:Integer, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(FillArrays.fillsimilar), FillArrays.AbstractFill{T, N, Axes} where Axes where N where T, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7422850dbae0)[ Core.MethodMatch(spec_types=Tuple{typeof(FillArrays.fillsimilar), FillArrays.Ones{T, N, Axes} where Axes where N, Tuple{Base.OneTo{Int64}}} where T, sparams=svec(T), method=fillsimilar(FillArrays.Ones{T, N, Axes} where Axes where N, Any...) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(FillArrays.fillsimilar), FillArrays.Zeros{T, N, Axes} where Axes where N, Tuple{Base.OneTo{Int64}}} where T, sparams=svec(T), method=fillsimilar(FillArrays.Zeros{T, N, Axes} where Axes where N, Any...) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(FillArrays.fillsimilar), FillArrays.AbstractFill{T, N, Axes} where Axes where N where T, Tuple{Base.OneTo{Int64}}}, sparams=svec(), method=fillsimilar(FillArrays.AbstractFill{T, N, Axes} where Axes where N where T, Any...), fully_covers=true), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009681, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:Tuple{Int64, Array{R, 1} where R}, Tuple{Int64, Array{R, 1} where R}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x742285749ca0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Tuple{Int64, Array{R, 1} where R}}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, Tuple{Int64, Array{R, 1} where R}} where T<:Tuple{Int64, Array{R, 1} where R}, sparams=svec(T<:Tuple), method=convert(Type{T}, T) where {T<:Tuple}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:Tuple{Int64, Array{R, 1} where R}, Tuple{Int64, Array{R, 1} where R}}, sparams=svec(2, var"#s175"<:Tuple{Int64, Array{R, 1} where R}), 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{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:Tuple{Any, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R, Array{R, 1} where R}}, Tuple{Any, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R, Array{R, 1} where R}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x74228aea9260)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Tuple{Any, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R, Array{R, 1} where R}}}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, Tuple{Any, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R, Array{R, 1} where R}}} where T<:Tuple{Any, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R, Array{R, 1} where R}}, sparams=svec(T<:Tuple), method=convert(Type{T}, T) where {T<:Tuple}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:Tuple{Any, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R, Array{R, 1} where R}}, Tuple{Any, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R, Array{R, 1} where R}}}, sparams=svec(2, var"#s175"<:Tuple{Any, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R, Array{R, 1} where R}}), 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{typeof(ReverseDiff.value), Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isprimitivetype), Type{UInt32}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228abbc0c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.isprimitivetype), Type{UInt32}}, sparams=svec(), method=isprimitivetype(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000501, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, typeof(Base.sqrt), Tuple{AbstractArray{T, 1} where T<:Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742270c70900)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, typeof(Base.sqrt), Tuple{AbstractArray{T, 1} where T<:Real}}, sparams=svec(typeof(Base.sqrt)), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.preprocess_args), Base.SubArray{T, 1, P, I, L} where L where I where P where T, Tuple{Base.SubArray{T, 1, P, I, L} where L where I where P where T, Array{T, 1} where T<:Number}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742270f2f4a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.preprocess_args), Base.SubArray{T, 1, P, I, L} where L where I where P where T, Tuple{Base.SubArray{T, 1, P, I, L} where L where I where P where T, Array{T, 1} where T<:Number}}, sparams=svec(), method=preprocess_args(Any, Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048cd, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.length), Array{var"#s4711", 1} where var"#s4711"<:Float64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742284e57840)[Core.MethodMatch(spec_types=Tuple{typeof(Base.length), Array{var"#s4711", 1} where var"#s4711"<:Float64}, sparams=svec(var"#s4711"<:Float64), method=length(Array{T, 1}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000030c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.dotgetproperty), LinearAlgebra.Diagonal{T, Array{T, 1}} where T<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742285bb7f40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.dotgetproperty), LinearAlgebra.Diagonal{T, Array{T, 1}} where T<:Real, Symbol}, sparams=svec(), method=dotgetproperty(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000286, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.min), Integer, Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226e4429a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.min), T, T} where T<:Integer, sparams=svec(T<:T<:Integer), method=min(T, T) where {T<:Real}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.min), Integer, Integer}, sparams=svec(), method=min(Real, Real), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000065c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Base.RefValue{typeof(Base.:(*))}, AbstractArray{T, N} where N where T, Array{T, N} where N where T} where var"#s175"<:Tuple{Base.RefValue{typeof(Base.:(*))}, AbstractArray{T, N} where N where T, Array{T, N} where N where T}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228c38d540)[Core.MethodMatch(spec_types=Tuple{Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Base.RefValue{typeof(Base.:(*))}, AbstractArray{T, N} where N where T, Array{T, N} where N where T} where var"#s175"<:Tuple{Base.RefValue{typeof(Base.:(*))}, AbstractArray{T, N} where N where T, Array{T, N} where N where T}, Int64}, sparams=svec(var"#s175"<:Tuple{Base.RefValue{typeof(Base.:(*))}, AbstractArray{T, N} where N where T, Array{T, N} where N where T}), method=(::Base.var"#cvt1#convert##0"{T, x})(Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000376, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LinearAlgebra._parent_tri), Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226f171060)[ Core.MethodMatch(spec_types=Tuple{typeof(LinearAlgebra._parent_tri), Union{LinearAlgebra.LowerTriangular{T, S}, LinearAlgebra.UnitLowerTriangular{T, S}, LinearAlgebra.UnitUpperTriangular{T, S}, LinearAlgebra.UpperTriangular{T, S}} where S where T}, sparams=svec(), method=_parent_tri(Union{LinearAlgebra.LowerTriangular{T, S}, LinearAlgebra.UnitLowerTriangular{T, S}, LinearAlgebra.UnitUpperTriangular{T, S}, LinearAlgebra.UpperTriangular{T, S}} where S where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(LinearAlgebra._parent_tri), Any}, sparams=svec(), method=_parent_tri(Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000087e7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:(Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Ti, 1} where Ti<:Integer)), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Ti, 1} where Ti<:Integer)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x742284f58c60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Ti, 1} where Ti<:Integer)}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Ti, 1} where Ti<:Integer)} where T<:(Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Ti, 1} where Ti<:Integer)), sparams=svec(T), method=convert(Type{T}, T) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000034c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.axes), FillArrays.Fill{Float64, 1, Axes} where Axes}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d712ec0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.axes), FillArrays.Fill{Float64, 1, Axes} where Axes}, sparams=svec(), method=axes(FillArrays.Fill{T, N, Axes} where Axes where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009681, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{JSOSolvers.TRONParameterSet{T} where T}, SolverParameters.Parameter{_A, SolverParameters.RealInterval{_A}} where _A<:Real, SolverParameters.Parameter{_A, SolverParameters.RealInterval{_A}} where _A<:Real, SolverParameters.Parameter{_A, SolverParameters.RealInterval{_A}} where _A<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228c2dbfa0)[Core.MethodMatch(spec_types=Tuple{Type{JSOSolvers.TRONParameterSet{T} where T}, SolverParameters.Parameter{T, SolverParameters.RealInterval{T}}, SolverParameters.Parameter{T, SolverParameters.RealInterval{T}}, SolverParameters.Parameter{T, SolverParameters.RealInterval{T}}} where T<:Real, sparams=svec(T<:Real), method=(::Type{JSOSolvers.TRONParameterSet{T} where T})(SolverParameters.Parameter{T, SolverParameters.RealInterval{T}}, SolverParameters.Parameter{T, SolverParameters.RealInterval{T}}, SolverParameters.Parameter{T, SolverParameters.RealInterval{T}}) where {T}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096c8, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, Any, Tuple{Base.RefValue{typeof(Base.min)}, AbstractArray{T, 1} where T, AbstractArray{T, N} where N where T}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7422726d8c60)[ Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, Tuple, Tuple{Base.RefValue{typeof(Base.min)}, AbstractArray{T, 1} where T, AbstractArray{T, N} where N where T}}, sparams=svec(), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, Tuple, Tuple), fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, Any, Tuple{Base.RefValue{typeof(Base.min)}, AbstractArray{T, 1} where T, AbstractArray{T, N} where N where T}}, sparams=svec(F), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple) where {F}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{FillArrays.Fill{Float64, 1, Tuple{Base.OneTo{Int64}}}, Array{T, 1} where T<:Number} where var"#s175"<:Tuple{FillArrays.Fill{Float64, 1, Tuple{Base.OneTo{Int64}}}, Array{T, 1} where T<:Number}, Base.Val{2}}, limit=5), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d87ca40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{FillArrays.Fill{Float64, 1, Tuple{Base.OneTo{Int64}}}, Array{T, 1} where T<:Number} where var"#s175"<:Tuple{FillArrays.Fill{Float64, 1, Tuple{Base.OneTo{Int64}}}, Array{T, 1} where T<:Number}, Base.Val{2}}, sparams=svec(), method=ntuple(Any, Base.Val{2}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000017db, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.merge), NamedTuple{(:history, :scaling, :display), Tuple{Bool, Bool, Bool}}, NamedTuple{names, T} where T<:Tuple{Vararg{Any, N}} where names where N}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226ea20b60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.merge), NamedTuple{(:history, :scaling, :display), Tuple{Bool, Bool, Bool}}, NamedTuple{(), T} where T<:Tuple{Vararg{Any, N}} where N}, sparams=svec(), method=merge(NamedTuple{names, T} where T<:Tuple where names, NamedTuple{(), T} where T<:Tuple), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.merge), NamedTuple{(:history, :scaling, :display), Tuple{Bool, Bool, Bool}}, NamedTuple{names, T} where T<:Tuple{Vararg{Any, N}} where names where N}, sparams=svec((:history, :scaling, :display), names), method=merge(NamedTuple{an, T} where T<:Tuple, NamedTuple{bn, T} where T<:Tuple) where {an, bn}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001a9e, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Type{Bool}, Array{Float64, 1}, Base.UnitRange{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74228c396760)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Type{Bool}, Array{Float64, 1}, Base.UnitRange{Int64}}, sparams=svec(), method=checkbounds(Type{Bool}, AbstractArray{T, N} where N where T, Any), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000127a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(<)), Array{_A, 1} where _A, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74228ab87420)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(<)), Array{_A, 1} where _A, Any}, sparams=svec(typeof(Base.:(<))), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004959, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Ptr{SparseArrays.CHOLMOD.cholmod_l_sparse_struct_typed}}, Ptr{SparseArrays.LibSuiteSparse.cholmod_sparse_struct}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273306620)[Core.MethodMatch(spec_types=Tuple{Type{Ptr{SparseArrays.CHOLMOD.cholmod_l_sparse_struct_typed}}, Ptr{SparseArrays.LibSuiteSparse.cholmod_sparse_struct}}, sparams=svec(), method=(::Type{Ptr{T}})(Union{Int64, UInt64, Ptr{T} where T}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000222, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isconcretetype), Type{CodecZlib.ZStream}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d034540)[Core.MethodMatch(spec_types=Tuple{typeof(Base.isconcretetype), Type{CodecZlib.ZStream}}, sparams=svec(), method=isconcretetype(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000051d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Tuple{Tuple{Int64}, Tuple{Any}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228cb1cf60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Tuple{Tuple{Int64}, Tuple{Any}}, Int64}, sparams=svec(), method=getindex(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000669, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{SolverTest.var"##kkt_checker#1", Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(SolverTest.kkt_checker), ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74227305aae0)[Core.MethodMatch(spec_types=Tuple{SolverTest.var"##kkt_checker#1", Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(SolverTest.kkt_checker), ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T, Any}, sparams=svec(T, S), method=var"#kkt_checker#1"(Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where T<:Tuple{Vararg{Any, N}} where names where N where V, typeof(SolverTest.kkt_checker), NLPModels.AbstractNLPModel{T, S}, Any) where {T, S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976e, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.round), Type{Int64}, Float64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228a09e720)[Core.MethodMatch(spec_types=Tuple{typeof(Base.round), Type{Int64}, Float64}, sparams=svec(Int64), method=round(Type{T}, Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000d50, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.:(-)), Tuple{Array{R, 1} where R}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a8fbc800)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.:(-)), Tuple{Array{R, 1} where R}}, sparams=svec(typeof(Base.:(-))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._tuple_error), Type{var"#s175"} where var"#s175"<:Tuple{Base.Broadcast.Broadcasted{var"#s179", Nothing, typeof(Base.sqrt), var"#s179"} where var"#s179"<:Tuple{AbstractArray{T, 1} where T<:Real} where var"#s179"<:Base.Broadcast.BroadcastStyle}, Tuple{Base.Broadcast.Broadcasted{var"#s179", Nothing, typeof(Base.sqrt), var"#s179"} where var"#s179"<:Tuple{AbstractArray{T, 1} where T<:Real} where var"#s179"<:Base.Broadcast.BroadcastStyle}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226bff67c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._tuple_error), Type{var"#s175"} where var"#s175"<:Tuple{Base.Broadcast.Broadcasted{var"#s179", Nothing, typeof(Base.sqrt), var"#s179"} where var"#s179"<:Tuple{AbstractArray{T, 1} where T<:Real} where var"#s179"<:Base.Broadcast.BroadcastStyle}, Tuple{Base.Broadcast.Broadcasted{var"#s179", Nothing, typeof(Base.sqrt), var"#s179"} where var"#s179"<:Tuple{AbstractArray{T, 1} where T<:Real} where var"#s179"<:Base.Broadcast.BroadcastStyle}}, sparams=svec(), method=_tuple_error(Type, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000372, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{NamedTuple{(:ap,), T} where T<:Tuple}, Tuple{RipQP.RipQPMonoParameters{T, _A, RipQP.PC} where _A<:RipQP.SolverParams{T} where T<:Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228a2d0540)[Core.MethodMatch(spec_types=Tuple{Type{NamedTuple{(:ap,), T} where T<:Tuple}, Tuple{RipQP.RipQPMonoParameters{T, _A, RipQP.PC} where _A<:RipQP.SolverParams{T} where T<:Real}}, sparams=svec((:ap,)), 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.map), typeof(Base.Broadcast.broadcastable), Tuple{Array{T, N} where N where T, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742271960e60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.map), typeof(Base.Broadcast.broadcastable), Tuple{Array{T, N} where N where T, Any}}, sparams=svec(), method=map(Any, Tuple{Any, Any}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006bd, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{LinearOperators.var"##_#2", Type, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where T, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##14#PreconditionerData##15"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real, Nothing, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226ccfc480)[Core.MethodMatch(spec_types=Tuple{LinearOperators.var"##_#2", Type, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where T, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##14#PreconditionerData##15"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real, Nothing, Nothing}, sparams=svec(T, Int64), method=var"#_#2"(Type, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, I, I, Bool, Bool, Any, Any, Any) where {T, I<:Integer}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Number)} where var"#s175"<:Tuple{Base.Broadcast.Extruded{FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Number)}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273bc1860)[Core.MethodMatch(spec_types=Tuple{Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Number)} where var"#s175"<:Tuple{Base.Broadcast.Extruded{FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Number)}, Int64}, sparams=svec(var"#s175"<:Tuple{Base.Broadcast.Extruded{FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Number)}), method=(::Base.var"#cvt1#convert##0"{T, x})(Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000376, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{FillArrays.OneElement{T, N, I, A} where A where I where N where T}, Any, Any, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{Type{ft} where ft<:(Array{T, 1} where T<:Number), FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74228528f520)[ Core.MethodMatch(spec_types=Tuple{Type{Union{}}, FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}}, sparams=svec(), method=(::Type{Union{}})(Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{Array{T, 1}}, FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}} where T<:Number, sparams=svec(T<:Number, Float64, 1), method=(::Type{Array{T, N}})(FillArrays.AbstractOnes{V, N, Axes} where Axes) where {T, V, N}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009681, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Iterators._zip_isdone), Tuple{Any, Any}, Tuple{Tuple{}, Tuple{}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422722a7140)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators._zip_isdone), Tuple{Any, Any}, Tuple{Tuple{}, Tuple{}}}, sparams=svec(), method=_zip_isdone(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000018ce, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), Base.Broadcast.DefaultArrayStyle{2}, typeof(SparseMatricesCOO.replace_if_minusinf), LinearAlgebra.Adjoint{Float64, var"#s179"} where var"#s179"<:AbstractArray{Float64, 1}, Float64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74228f3951e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Base.Broadcast.DefaultArrayStyle{2}, typeof(SparseMatricesCOO.replace_if_minusinf), LinearAlgebra.Adjoint{Float64, var"#s179"} where var"#s179"<:AbstractArray{Float64, 1}, Float64}, sparams=svec(typeof(SparseMatricesCOO.replace_if_minusinf)), method=broadcasted(Base.Broadcast.BroadcastStyle, F, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000495a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.identity), Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.axes), Array{T, 1} where T<:Real, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228f6267e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.axes), Array{T, 1} where T<:Real, Int64}, sparams=svec(T<:Real, 1), method=axes(AbstractArray{T, N}, Any) where {T, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001229, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), Memory{Any}, Array{QuadraticModels.PresolveOperation{T, _A}, 1} where _A where T<:Real, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226cf13060)[Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Memory{Any}, Array{QuadraticModels.PresolveOperation{T, _A}, 1} where _A where T<:Real, Int64}, sparams=svec(), method=setindex!(Memory{Any}, Any, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000039c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IteratorSize}, Tuple{Pair{Symbol, Nothing}, Pair{Symbol, Array{QuadraticModels.PresolveOperation{T, _A}, 1}} where _A where T<:Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d655840)[Core.MethodMatch(spec_types=Tuple{Type{Base.IteratorSize}, Tuple{Pair{Symbol, Nothing}, Pair{Symbol, Array{QuadraticModels.PresolveOperation{T, _A}, 1}} where _A where T<:Real}}, sparams=svec(), method=(::Type{Base.IteratorSize})(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000445, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{Array{QuadraticModels.PresolveOperation{T, _A}, 1} where _A where T<:Real, Int64}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d29fa60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{Array{QuadraticModels.PresolveOperation{T, _A}, 1} where _A where T<:Real, Int64}, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000688, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{LinearOperators.var"##LinearOperator#14", Type{Array{T, 1}} where T<:Real, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, Type{T} where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##14#PreconditionerData##15"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Int64, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Tf<:Real) where Tlow<:Real, Nothing, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a7b58860)[Core.MethodMatch(spec_types=Tuple{LinearOperators.var"##LinearOperator#14", Type{Array{T, 1}} where T<:Real, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, Type{T} where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##14#PreconditionerData##15"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Int64, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Tf<:Real) where Tlow<:Real, Nothing, Nothing}, sparams=svec(T<:Real, Int64), method=var"#LinearOperator#14"(Any, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, Type{T}, I, I, Bool, Bool, Any, Any, Any) where {T, I<:Integer}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.factorize_K2!), LinearAlgebra.Symmetric{T, _B} where _B<:AbstractArray{T, 2} where T<:Real, RipQP.LDLFactorizationData{T} where T, Any, SparseArrays.SparseVector{T, Int64} where T<:Real, Array{Int64, 1}, RipQP.Regularization{T} where T<:Real, Any, Any, Any, Any, Array{Int64, 1}, Array{Int64, 1}, Int64, Int64, RipQP.Counters, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226e1ece40)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.factorize_K2!), LinearAlgebra.Symmetric{T, _B} where _B<:AbstractArray{T, 2}, RipQP.LDLFactorizationData{Tlow}, AbstractArray{T, 1}, SparseArrays.SparseVector{T, Int64}, Array{Int64, 1}, RipQP.Regularization{Tlow}, AbstractArray{T, 1}, AbstractArray{T, 1}, AbstractArray{T, 1}, AbstractArray{T, 1}, Array{Int64, 1}, Array{Int64, 1}, Int64, Int64, RipQP.Counters, Bool} where Tlow<:Real where T<:Real, sparams=svec(T<:Real, Tlow<:Real), method=factorize_K2!(LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4711", 2} where var"#s4711"<:T), RipQP.FactorizationData{Tlow}, AbstractArray{T, 1}, SparseArrays.AbstractSparseArray{T, Ti, 1} where Ti, Any, RipQP.Regularization{Tlow}, AbstractArray{T, 1}, AbstractArray{T, 1}, AbstractArray{T, 1}, AbstractArray{T, 1}, Any, Any, Any, Any, RipQP.Counters, Bool) where {T, Tlow}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(DiffResults.jacobian), DiffResults.MutableDiffResult{O, V, D} where D<:Tuple where V where O}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742283372f40)[Core.MethodMatch(spec_types=Tuple{typeof(DiffResults.jacobian), DiffResults.MutableDiffResult{O, V, D} where D<:Tuple where V where O}, sparams=svec(), method=jacobian(DiffResults.DiffResult{O, V, D} where D<:Tuple where V where O), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000968d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Dict{K, V} where V where K}, Vararg{Pair{Symbol, String}, 5}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228a925f60)[Core.MethodMatch(spec_types=Tuple{Type{Base.Dict{K, V} where V where K}, Vararg{Pair{Symbol, String}, 5}}, sparams=svec(Symbol, String), method=(::Type{Base.Dict{K, V} where V where K})(Pair{K, V}...) where {K, V}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000034b8, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{LinearAlgebra.Symmetric{T, var"#s179"}} where var"#s179"<:AbstractArray{var"#s4711", 2} where var"#s4711" where T, AbstractArray{var"#s4711", 2} where var"#s4711", Char}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228ad305a0)[Core.MethodMatch(spec_types=Tuple{Type{LinearAlgebra.Symmetric{T, S}}, AbstractArray{var"#s4711", 2} where var"#s4711", Char} where S<:AbstractArray{var"#s4711", 2} where var"#s4711"<:T where T, sparams=svec(T, S<:AbstractArray{var"#s4711"<:T, 2}), method=(::Type{LinearAlgebra.Symmetric{T, S}})(Any, Char) where {T, S<:(AbstractArray{var"#s4709", 2} where var"#s4709"<:T)}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000008796, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.sqrt), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real)}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228596c8a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.sqrt), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real)}, Tuple{Base.OneTo{Int64}}}, sparams=svec(), method=_axes(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047da, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.empty), Base.Dict{Any, Any}, Type{Symbol}, Type{QuadraticModels.PresolvedQuadraticModel{Float64, Array{Float64, 1}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742288b3a720)[Core.MethodMatch(spec_types=Tuple{typeof(Base.empty), Base.Dict{Any, Any}, Type{Symbol}, Type{QuadraticModels.PresolvedQuadraticModel{Float64, Array{Float64, 1}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}}}}, sparams=svec(Symbol, QuadraticModels.PresolvedQuadraticModel{Float64, Array{Float64, 1}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}}), method=empty(Base.AbstractDict{K, V} where V where K, Type{K}, Type{V}) where {K, V}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000034be, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Array{Int64, 1}, Real}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226ca89620)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Array{Int64, 1}, Real}, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._trimmedvind), Vararg{Union{Real, Base.AbstractRange{var"#s16"} where var"#s16"<:Real, Array{var"#s15", N} where N where var"#s15"<:Union{Real, Base.AbstractCartesianIndex{N} where N}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x74226f2fe4e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base._trimmedvind)}, sparams=svec(), method=_trimmedvind(), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base._trimmedvind), Union{Base.AbstractRange{Union{}}, Array{var"#s15", N} where N where var"#s15"<:Base.AbstractCartesianIndex{0}}, Vararg{Union{Real, Base.AbstractRange{var"#s16"} where var"#s16"<:Real, Array{var"#s15", N} where N where var"#s15"<:Union{Real, Base.AbstractCartesianIndex{N} where N}}}}, sparams=svec(), method=_trimmedvind(AbstractArray{var"#s16", N} where N where var"#s16"<:Base.AbstractCartesianIndex{0}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base._trimmedvind), Union{Real, Base.AbstractRange{var"#s16"} where var"#s16"<:Real, Array{var"#s15", N} where N where var"#s15"<:Union{Real, Base.AbstractCartesianIndex{N} where N}}, Vararg{Union{Real, Base.AbstractRange{var"#s16"} where var"#s16"<:Real, Array{var"#s15", N} where N where var"#s15"<:Union{Real, Base.AbstractCartesianIndex{N} where N}}}}, sparams=svec(), method=_trimmedvind(Any, Any...), fully_covers=false), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002dc1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.GenericIOBuffer{Memory{UInt8}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e9652e0)[Core.MethodMatch(spec_types=Tuple{Type{Base.GenericIOBuffer{Memory{UInt8}}}}, sparams=svec(), method=(::Type{Base.GenericIOBuffer{Memory{UInt8}}})(), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003926, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{V} where V<:(Array{T, 1} where T<:Real), Array{Tlow, 1} where Tlow<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226eddf2a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Array{Tlow, 1} where Tlow<:Real}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{V} where V<:(Array{T, 1} where T<:Real), Array{Tlow, 1} where Tlow<:Real}, sparams=svec(V<:(Array{T, 1} where T<:Real)), method=convert(Type{T}, AbstractArray{T, N} where N where T) where {T<:(Array{T, N} where N where T)}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010dd, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Sort._hi), Array{Int64, 1}, Base.Order.ForwardOrdering, NamedTuple{(:lo, :hi, :legacy_dispatch_entry), var"#s179"} where var"#s179"<:Tuple{Integer, Integer, Base.Sort.InsertionSortAlg}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422877ab3e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Sort._hi), Array{Int64, 1}, Base.Order.ForwardOrdering, NamedTuple{(:lo, :hi, :legacy_dispatch_entry), var"#s179"} where var"#s179"<:Tuple{Integer, Integer, Base.Sort.InsertionSortAlg}}, sparams=svec(), method=_hi(Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000005bfa, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.preprocess), SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv<:Real, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, typeof(Base.abs), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R<:Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228dc17fa0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.preprocess), SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv<:Real, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, typeof(Base.abs), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R<:Real}}, sparams=svec(), method=preprocess(Any, Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048ca, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.show_used_solver), RipQP.PreallocatedDataK2LDL{T, _A, F, _B} where _B<:AbstractArray{T, 2} where F<:(RipQP.LDLFactorizationData{T} where T) where _A where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742272e993a0)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.show_used_solver), RipQP.PreallocatedDataK2LDL{T, _A, F, _B} where _B<:AbstractArray{T, 2} where F<:(RipQP.LDLFactorizationData{T} where T) where _A where T<:Real}, sparams=svec(T<:Real), method=show_used_solver(RipQP.PreallocatedData{T, S} where S) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Tuple{Pair{Symbol, Nothing}, Vararg{Pair{A, B} where B where A}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742271bc2460)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Tuple{Pair{Symbol, Nothing}, Vararg{Pair{A, B} where B where A}}, Int64}, sparams=svec(), method=getindex(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000669, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.fill!), AbstractArray{Float64, 1}, Float64}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unsafe_copyto!), GenericMemoryRef{:not_atomic, T, Core.AddrSpace{Core}(0x00)} where T, GenericMemoryRef{:not_atomic, T, Core.AddrSpace{Core}(0x00)} where T, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74228de04660)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_copyto!), GenericMemoryRef{:not_atomic, T, Core.AddrSpace{Core}(0x00)}, GenericMemoryRef{:not_atomic, T, Core.AddrSpace{Core}(0x00)}, Int64} where T, sparams=svec(T), method=unsafe_copyto!(GenericMemoryRef{:not_atomic, T, Core.AddrSpace{Core}(0x00)}, GenericMemoryRef{:not_atomic, T, Core.AddrSpace{Core}(0x00)}, Any) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_copyto!), GenericMemoryRef{:not_atomic, T, Core.AddrSpace{Core}(0x00)} where T, GenericMemoryRef{:not_atomic, T, Core.AddrSpace{Core}(0x00)} where T, Int64}, sparams=svec(), method=unsafe_copyto!(GenericMemoryRef{isatomic, T, addrspace} where addrspace where T where isatomic, GenericMemoryRef{isatomic, T, addrspace} where addrspace where T where isatomic, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001043, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ReverseDiff.value), ReverseDiff.TrackedReal{V, D, O} where O<:(ReverseDiff.TrackedArray{V, D, 1, VA, DA} where V<:Real where D<:Real where VA<:(Array{T, 1} where T<:Real) where DA<:(Array{T, 1} where T<:Real)) where D<:Real where V<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a7a4a280)[Core.MethodMatch(spec_types=Tuple{typeof(ReverseDiff.value), ReverseDiff.TrackedReal{V, D, O} where O<:(ReverseDiff.TrackedArray{V, D, 1, VA, DA} where V<:Real where D<:Real where VA<:(Array{T, 1} where T<:Real) where DA<:(Array{T, 1} where T<:Real)) where D<:Real where V<:Real}, sparams=svec(), method=value(ReverseDiff.TrackedReal{V, D, O} where O where D<:Real where V<:Real), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.set_ripqp_solver_specific!), SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T<:Real, Symbol, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742284ed8fe0)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.set_ripqp_solver_specific!), SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T<:Real, Symbol, Int64}, sparams=svec(), method=set_ripqp_solver_specific!(SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T, Symbol, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Memory{UInt8}}, UndefInitializer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a72d11e0)[Core.MethodMatch(spec_types=Tuple{Type{Memory{UInt8}}, UndefInitializer, Int64}, sparams=svec(UInt8, 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(Base.promote_type), Type{Tuple{String, Main.var"#tests##0#tests##1"{Main.var"#tests##2#tests##3"}}}, Type{Tuple{String, typeof(JSOSolvers.lbfgs)}}, Type{Tuple{String, typeof(JSOSolvers.tron)}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228f125160)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_type), Type{Tuple{String, Main.var"#tests##0#tests##1"{Main.var"#tests##2#tests##3"}}}, Type{Tuple{String, typeof(JSOSolvers.lbfgs)}}, Type{Tuple{String, typeof(JSOSolvers.tron)}}}, sparams=svec(), method=promote_type(Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000005f3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.cconvert), Type{Ptr{T}} where T<:Real, Array{T, 1} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(6, 0x742283130340)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.cconvert), Type{Ptr{Union{}}}, Array{Union{}, 1}}, sparams=svec(Union{}), method=cconvert(Type{Ptr{P}}, Array{var"#s16", N} where N where var"#s16"<:Union{Base.Cstring, Base.Cwstring, Ptr{T} where T}) where {P<:Union{Base.Cstring, Base.Cwstring, Ptr{T} where T}}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.cconvert), Type{Ptr{Union{}}}, Array{T, 1} where T<:Real}, sparams=svec(Union{}), method=cconvert(Type{Ptr{P}}, Array{T, N} where N where T) where {P<:Union{Base.Cstring, Base.Cwstring, Ptr{T} where T}}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.cconvert), Type{Ptr{T}} where T<:Real, Array{T, 1} where T<:Real}, 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=0x0000000000002d67, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{Union{QuadraticModels.AbstractQuadraticModel{Float64, S} where S, QuadraticModels.QuadraticModel{_A, _B, _C, _D} where _D where _C where _B where _A}, SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T, RipQP.IntDataInit{I} where I<:Integer}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228ca94a80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{Union{QuadraticModels.AbstractQuadraticModel{Float64, S} where S, QuadraticModels.QuadraticModel{_A, _B, _C, _D} where _D where _C where _B where _A}, SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T, RipQP.IntDataInit{I} where I<:Integer}, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000688, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Type{Bool}, FillArrays.AbstractFill{T, 1, Axes} where Axes where T<:Real, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74228ee1b5a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Type{Bool}, FillArrays.AbstractFill{T, 1, Axes} where Axes where T<:Real, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(), method=checkbounds(Type{Bool}, AbstractArray{T, N} where N where T, Any), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000127a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), var"#s179"} where var"#s179"<:Tuple{Type}, Type{LinearOperators.LinearOperator{Float64, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, Int64, Int64, Bool, Bool, Function, Nothing, Nothing, Int64, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a8b52c40)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), var"#s179"} where var"#s179"<:Tuple{Type}, Type{LinearOperators.LinearOperator{Float64, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, Int64, Int64, Bool, Bool, Function, Nothing, Nothing, Int64, Int64, Int64}, sparams=svec(Float64, Int64, F<:Function, Nothing, Nothing), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, I, I, Bool, Bool, F, Ft, Fct, I, I, I) where {T, I<:Integer, F, Ft, Fct}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), Array{T, 1} where T<:Union{Float32, Float64}, Array{_A, 1} where _A}, limit=1), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{Array{T, 1} where T<:Real, ReverseDiff.var"#24#25"{Tuple{Int64}}}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a9770d40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{Array{T, 1} where T<:Real, ReverseDiff.var"#24#25"{Tuple{Int64}}}, Int64, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000689, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.__safe_setindex!), Array{ReverseDiff.AbstractInstruction, 1}, ReverseDiff.SpecialInstruction{F, _A, _B, _C} where _C where _B where _A where F<:Function, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7422a6ef8220)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.__safe_setindex!), Array{ReverseDiff.AbstractInstruction, 1}, ReverseDiff.SpecialInstruction{F, _A, _B, _C} where _C where _B where _A where F<:Function, Int64}, sparams=svec(ReverseDiff.AbstractInstruction), method=__safe_setindex!(Array{T, 1}, T, Int64) where {T}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000111d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(var"==")), Type{T0} where T0<:Real, Type{Float16}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422706d3020)[Core.MethodMatch(spec_types=Tuple{typeof(Base.:(var"==")), Type{T0} where T0<:Real, Type{Float16}}, sparams=svec(), method=var"=="(Type, Type), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000bcd, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.RefValue{typeof(Base.:(/))}, AbstractArray{T, N} where N where T, Array{T, N} where N where T}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742271b94be0)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.RefValue{typeof(Base.:(/))}, AbstractArray{T, N} where N where T, Array{T, N} where N where T}}}, sparams=svec(), method=(::Type{MethodError})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000009d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{var"#s175"} where var"#s175"<:(Memory{Tlow} where Tlow<:Union{Float32, Float64}), UndefInitializer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226f23fd60)[ Core.MethodMatch(spec_types=Tuple{Type{Union{}}, UndefInitializer, Int64}, sparams=svec(), method=(::Type{Union{}})(Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{Memory{T}}, UndefInitializer, Int64} where T<:Union{Float32, Float64}, sparams=svec(T<:Union{Float32, Float64}, Core.AddrSpace{Core}(0x00), :not_atomic), method=(::Type{GenericMemory{kind, T, addrspace}})(UndefInitializer, Int64) where {T, addrspace, kind}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000100, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SolverCore.solve!), Union{RipQP.RipQPTripleSolver{T, _A, Int64, _B, _C, Float64, T1, _D, _E, T2, _F, _G, _H} where _H<:(RipQP.PreallocatedFloatData{T1, _D, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T1, _D} where Dda<:RipQP.DescentDirectionAllocs{T1, _D} where Res<:RipQP.AbstractResiduals{T1, _D}) where _G<:(RipQP.Abstract_QM_FloatData{T, _A, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where _F<:(RipQP.Abstract_QM_FloatData{T2, S, M1, M2} where M2<:Union{AbstractArray{T2, 2}, LinearOperators.AbstractLinearOperator{T2}} where M1<:Union{AbstractArray{T2, 2}, LinearOperators.AbstractLinearOperator{T2}} where S) where T2<:Real where _E<:(RipQP.Abstract_QM_FloatData{T1, _D, M1, M2} where M2<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}} where M1<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}}) where _D where T1<:Real where _C<:RipQP.ScaleData{T, _A} where _B<:QuadraticModels.AbstractQuadraticModel{T, _A} where _A, RipQP.RipQPTripleSolver{T, _A, Int64, _B, _C, Float64, T1, S1, _E, T2, _F, _G, _H} where _H<:(RipQP.PreallocatedFloatData{T1, S1, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T1, S1} where Dda<:RipQP.DescentDirectionAllocs{T1, S1} where Res<:RipQP.AbstractResiduals{T1, S1}) where _G<:(RipQP.Abstract_QM_FloatData{T, _A, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where _F<:(RipQP.Abstract_QM_FloatData{T2, S, M1, M2} where M2<:Union{AbstractArray{T2, 2}, LinearOperators.AbstractLinearOperator{T2}} where M1<:Union{AbstractArray{T2, 2}, LinearOperators.AbstractLinearOperator{T2}} where S) where T2<:Real where _E<:(RipQP.Abstract_QM_FloatData{T1, S1, M1, M2} where M2<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}} where M1<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}}) where S1 where T1<:Real where _C<:RipQP.ScaleData{T, _A} where _B<:QuadraticModels.AbstractQuadraticModel{T, _A} where _A, RipQP.RipQPTripleSolver{T, S, Int64, _B, _C, Float64, T1, _D, _E, T2, _F, _G, _H} where _H<:(RipQP.PreallocatedFloatData{T1, _D, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T1, _D} where Dda<:RipQP.DescentDirectionAllocs{T1, _D} where Res<:RipQP.AbstractResiduals{T1, _D}) where _G<:(RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where _F<:(RipQP.Abstract_QM_FloatData{T2, S, M1, M2} where M2<:Union{AbstractArray{T2, 2}, LinearOperators.AbstractLinearOperator{T2}} where M1<:Union{AbstractArray{T2, 2}, LinearOperators.AbstractLinearOperator{T2}} where S) where T2<:Real where _E<:(RipQP.Abstract_QM_FloatData{T1, _D, M1, M2} where M2<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}} where M1<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}}) where _D where T1<:Real where _C<:RipQP.ScaleData{T, S} where _B<:QuadraticModels.AbstractQuadraticModel{T, S} where S, RipQP.RipQPTripleSolver{T, S, Int64, _B, _C, Float64, T1, S1, _E, T2, _F, _G, _H} where _H<:(RipQP.PreallocatedFloatData{T1, S1, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T1, S1} where Dda<:RipQP.DescentDirectionAllocs{T1, S1} where Res<:RipQP.AbstractResiduals{T1, S1}) where _G<:(RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where _F<:(RipQP.Abstract_QM_FloatData{T2, S, M1, M2} where M2<:Union{AbstractArray{T2, 2}, LinearOperators.AbstractLinearOperator{T2}} where M1<:Union{AbstractArray{T2, 2}, LinearOperators.AbstractLinearOperator{T2}} where S) where T2<:Real where _E<:(RipQP.Abstract_QM_FloatData{T1, S1, M1, M2} where M2<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}} where M1<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}}) where S1 where T1<:Real where _C<:RipQP.ScaleData{T, S} where _B<:QuadraticModels.AbstractQuadraticModel{T, S} where S} where T<:Real, QuadraticModels.QuadraticModel{T, S, M1, M2} where M2 where M1 where S where T, SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T, RipQP.RipQPTripleParameters{T, SP1, SP2, _A, RipQP.PC, RipQP.PC, RipQP.PC} where _A<:RipQP.SolverParams{T} where SP2<:(RipQP.SolverParams{T} where T) where SP1<:(RipQP.K2LDLParams{_A, RipQP.LDLFact} where _A) where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226c083840)[Core.MethodMatch(spec_types=Tuple{typeof(SolverCore.solve!), RipQP.RipQPTripleSolver{T, S, Int64, _B, _C, Float64, T1, S1, _E, T2, _F, _G, _H} where _H<:(RipQP.PreallocatedFloatData{T1, S1, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T1, S1} where Dda<:RipQP.DescentDirectionAllocs{T1, S1} where Res<:RipQP.AbstractResiduals{T1, S1}) where _G<:(RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where _F<:(RipQP.Abstract_QM_FloatData{T2, S, M1, M2} where M2<:Union{AbstractArray{T2, 2}, LinearOperators.AbstractLinearOperator{T2}} where M1<:Union{AbstractArray{T2, 2}, LinearOperators.AbstractLinearOperator{T2}} where S) where T2<:Real where _E<:(RipQP.Abstract_QM_FloatData{T1, S1, M1, M2} where M2<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}} where M1<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}}) where S1 where T1<:Real where _C<:RipQP.ScaleData{T, S} where _B<:QuadraticModels.AbstractQuadraticModel{T, S}, QuadraticModels.QuadraticModel{T, S, M1, M2} where M2 where M1, SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V, RipQP.RipQPTripleParameters{T, SP1, SP2, _A, RipQP.PC, RipQP.PC, RipQP.PC} where _A<:RipQP.SolverParams{T} where SP2<:(RipQP.SolverParams{T} where T) where SP1<:(RipQP.K2LDLParams{_A, RipQP.LDLFact} where _A) where T<:Real} where S where T<:Real, sparams=svec(T<:Real, S), method=solve!(RipQP.RipQPTripleSolver{T, S, I, QMType, Sd, Tsc, T1, S1, QMfd1, T2, QMfd2, QMfd3, Pfd} where Pfd<:(RipQP.PreallocatedFloatData{T1, S1, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T1, S1} where Dda<:RipQP.DescentDirectionAllocs{T1, S1} where Res<:RipQP.AbstractResiduals{T1, S1}) where QMfd3<:(RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where QMfd2<:(RipQP.Abstract_QM_FloatData{T2, S, M1, M2} where M2<:Union{AbstractArray{T2, 2}, LinearOperators.AbstractLinearOperator{T2}} where M1<:Union{AbstractArray{T2, 2}, LinearOperators.AbstractLinearOperator{T2}} where S) where T2 where QMfd1<:(RipQP.Abstract_QM_FloatData{T1, S1, M1, M2} where M2<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}} where M1<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}}) where S1 where T1 where Tsc<:Real where Sd<:RipQP.ScaleData{T, S} where QMType<:QuadraticModels.AbstractQuadraticModel{T, S} where I, QuadraticModels.AbstractQuadraticModel{T, S}, SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V, RipQP.RipQPTripleParameters{T, SP1, SP2, SP3, SM1, SM2, SM3} where SM3<:RipQP.SolveMethod where SM2<:RipQP.SolveMethod where SM1<:RipQP.SolveMethod where SP3<:RipQP.SolverParams{T} where SP2<:(RipQP.SolverParams{T} where T) where SP1<:(RipQP.SolverParams{T} where T) where T<:Real) where {T, S}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.dict_with_eltype), Base.var"#Dict##0#Dict##1", Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, Type{Pair{Symbol, Union{}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226eef9a60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.dict_with_eltype), Base.var"#Dict##0#Dict##1", Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, Type{Pair{Symbol, Union{}}}}, sparams=svec(Symbol, Union{}), method=dict_with_eltype(Any, Any, Union{Type{Pair{K, V}}, Type{Tuple{K, V}}}) where {K, V}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001786, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:Integer, Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(6, 0x7422a7fc0d90)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Integer}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, Integer} where T<:Integer, sparams=svec(T<:Number), method=convert(Type{T}, T) where {T<:Number}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:Integer, Integer}, sparams=svec(var"#s175"<:Integer), 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.Broadcast.broadcasted), typeof(Base.sqrt), AbstractArray{Float64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74228929d060)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.sqrt), AbstractArray{Float64, 1}}, sparams=svec(typeof(Base.sqrt)), method=broadcasted(F, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004958, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(<)), Integer, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._tuple_error), Type{var"#s175"} where var"#s175"<:Tuple{FillArrays.Zeros{_A, 1, Tuple{Base.OneTo{Int64}}} where _A}, Tuple{FillArrays.Zeros{_A, 1, Tuple{Base.OneTo{Int64}}} where _A}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742272d53d80)[Core.MethodMatch(spec_types=Tuple{typeof(Base._tuple_error), Type{var"#s175"} where var"#s175"<:Tuple{FillArrays.Zeros{_A, 1, Tuple{Base.OneTo{Int64}}} where _A}, Tuple{FillArrays.Zeros{_A, 1, Tuple{Base.OneTo{Int64}}} where _A}}, sparams=svec(), method=_tuple_error(Type, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000372, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type, Base.SubArray{E, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{T, 1} where T<:Real) where E<:Real}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), var"#s179"} where var"#s179"<:Tuple{Type}, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##16#PreconditionerData##17"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Nothing, Nothing, Int64, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a9a1ac60)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), var"#s179"} where var"#s179"<:Tuple{Type}, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##16#PreconditionerData##17"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Nothing, Nothing, Int64, Int64, Int64}, sparams=svec(T<:Real, Int64, F<:(RipQP.var"#PreconditionerData##16#PreconditionerData##17"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real), Nothing, Nothing), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, I, I, Bool, Bool, F, Ft, Fct, I, I, I) where {T, I<:Integer, F, Ft, Fct}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), SparseConnectivityTracer.HessianTracer{P} where P<:SparseConnectivityTracer.AbstractHessianPattern, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a9635820)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), SparseConnectivityTracer.HessianTracer{P} where P<:SparseConnectivityTracer.AbstractHessianPattern, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), LinearAlgebra.Adjoint{Float64, Array{Float64, 1}}, Any, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228dfa93e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), LinearAlgebra.Adjoint{Float64, Array{Float64, 1}}, Any, Int64}, sparams=svec(), method=setindex!(Union{LinearAlgebra.Adjoint{T, V}, LinearAlgebra.Transpose{T, V}} where V<:(AbstractArray{T, 1} where T) where T, Any, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000007afd, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), SparseArrays.CHOLMOD.Factor{Tv, Int32} where Tv<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a80e4a60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), SparseArrays.CHOLMOD.Factor{Tv, Int32} where Tv<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}, Int64}, sparams=svec(), method=size(SparseArrays.CHOLMOD.Factor{Tv, Ti} where Ti<:Union{Int32, Int64} where Tv<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}, Integer), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009675, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IndexStyle}, Base.BitArray{2}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74228ba23620)[ Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Base.BitArray{2}}, sparams=svec(), method=(::Type{Base.IndexStyle})(AbstractArray{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000fa4, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), Any, Base.RefValue{T} where T, Any, Array{T, N} where N where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742285d5a460)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), Any, Base.RefValue{T} where T, Any, Array{T, N} where N where T}, sparams=svec(), method=combine_styles(Any, Any, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004833, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.map), typeof(Base.Broadcast.broadcastable), Tuple{Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a8e93ec0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.map), typeof(Base.Broadcast.broadcastable), Tuple{Any}}, sparams=svec(), method=map(Any, Tuple{Any}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006bc, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(-)), Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Int64}}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742286327600)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(-)), Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Int64}}, 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(RipQP.update_rngbounds!), Any, Array{Int64, 1}, Any, Any, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228db866c0)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.update_rngbounds!), Array{T, 1}, Array{Int64, 1}, Any, Any, Any} where T<:Real, sparams=svec(T<:Real), method=update_rngbounds!(Array{T, 1}, Any, Any, Any, Any) where {T<:Real}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.print_to_string), Int64, String, Int64, String, Any, String, Any, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a6f47ca0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.print_to_string), Int64, String, Int64, String, Any, String, Any, String}, sparams=svec(), method=print_to_string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003dae, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Iterators._zip_iterate_all), Tuple{Array{Symbol, 1}, AbstractArray{typeof(DataType), 1}}, Tuple{Tuple{}, Tuple{}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d2f3ac0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators._zip_iterate_all), Tuple{Array{Symbol, 1}, AbstractArray{typeof(DataType), 1}}, Tuple{Tuple{}, Tuple{}}}, sparams=svec(), method=_zip_iterate_all(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000018c4, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setproperty!), LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Int64, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Tf<:Real, Symbol, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422868a3a80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.setproperty!), LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Int64, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Tf<:Real, Symbol, Bool}, sparams=svec(), method=setproperty!(Any, Symbol, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000284, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.uses_krylov), RipQP.PreallocatedData{Float64, S} where S<:AbstractArray{Float64, 1}}, limit=3), nothing, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4711", 2} where var"#s4711"<:T) where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74227481ae80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4711", 2} where var"#s4711"<:T) where T}, sparams=svec(), method=iterate(AbstractArray{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012c2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.keys), NamedTuple{(:droptol,), var"#s179"} where var"#s179"<:Tuple{Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742286060ea0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.keys), NamedTuple{(:droptol,), var"#s179"} where var"#s179"<:Tuple{Any}}, sparams=svec((:droptol,)), method=keys(NamedTuple{names, T} where T<:Tuple) where {names}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001aa6, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.show_log_row), RipQP.PreallocatedDataK2LDL{T, _A, F, _B} where _B<:AbstractArray{T, 2} where F<:(RipQP.LDLFactorizationData{T} where T) where _A where T<:Real, RipQP.IterData{T, S} where S where T<:Real, RipQP.AbstractResiduals{T, S} where S where T<:Real, RipQP.Counters, Any, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d677ac0)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.show_log_row), RipQP.PreallocatedDataK2LDL{T, _A, F, _B} where _B<:AbstractArray{T, 2} where F<:(RipQP.LDLFactorizationData{T} where T) where _A, RipQP.IterData{T, S} where S, RipQP.AbstractResiduals{T, S} where S, RipQP.Counters, Real, Real} where T<:Real, sparams=svec(T), method=show_log_row(RipQP.PreallocatedData{T, S} where S, RipQP.IterData{T, S} where S, RipQP.AbstractResiduals{T, S} where S, RipQP.Counters, T, T) where {T}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setproperty!), SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T<:Real, Symbol, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742284822fc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.setproperty!), SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T<:Real, Symbol, Symbol}, sparams=svec(), method=setproperty!(Any, Symbol, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000284, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:x0,), Tuple{Array{Float64, 1}}}, Any, Int64, SolverTest.var"#16#17", Int64, ADNLPModels.var"#3#4"}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.memoryref), Memory{QuadraticModels.PresolveOperation{T, S}} where S where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e137b20)[Core.MethodMatch(spec_types=Tuple{typeof(Core.memoryref), Memory{QuadraticModels.PresolveOperation{T, S}} where S where T<:Real}, sparams=svec(), method=memoryref(GenericMemory{isatomic, T, addrspace} where addrspace where T where isatomic), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000104, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.map), typeof(Base.Broadcast.broadcastable), Tuple{AbstractArray{Float64, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228354dec0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.map), typeof(Base.Broadcast.broadcastable), Tuple{AbstractArray{Float64, 1}}}, sparams=svec(), method=map(Any, Tuple{Any}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006bc, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Any, Base.RefValue{T} where T, Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}} where var"#s175"<:Tuple{Any, Base.RefValue{T} where T, Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}}, Base.Val{4}}, limit=5), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422831f1ae0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Any, Base.RefValue{T} where T, Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}} where var"#s175"<:Tuple{Any, Base.RefValue{T} where T, Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}}, Base.Val{4}}, sparams=svec(F<:(Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Any, Base.RefValue{T} where T, Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}} where var"#s175"<:Tuple{Any, Base.RefValue{T} where T, Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}}), 4), method=ntuple(F, Base.Val{N}) where {F, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000017e3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{NamedTuple{(:rng,), T} where T<:Tuple}, Tuple{Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228f474e80)[Core.MethodMatch(spec_types=Tuple{Type{NamedTuple{(:rng,), T} where T<:Tuple}, Tuple{Any}}, sparams=svec((:rng,)), 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.setindex!), AbstractArray{T, 1} where T, Int64, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.throw_boundserror), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(*)), var"#s179"} where var"#s179"<:Tuple{Int64, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422737d59e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.throw_boundserror), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(*)), var"#s179"} where var"#s179"<:Tuple{Int64, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Tuple{Int64}}, sparams=svec(), method=throw_boundserror(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000310, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.dataids), Base.LogicalIndex{Int64, Base.BitArray{N}} where N}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7422855916a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.dataids), Base.LogicalIndex{Int64, Base.BitArray{N}} where N}, sparams=svec(), method=dataids(AbstractArray{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000131f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._tuple_error), Type{var"#s175"} where var"#s175"<:Tuple{AbstractArray{T, 1} where Float64<:T<:Real, Float64}, Tuple{AbstractArray{T, 1} where Float64<:T<:Real, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228361a300)[Core.MethodMatch(spec_types=Tuple{typeof(Base._tuple_error), Type{var"#s175"} where var"#s175"<:Tuple{AbstractArray{T, 1} where Float64<:T<:Real, Float64}, Tuple{AbstractArray{T, 1} where Float64<:T<:Real, Float64}}, sparams=svec(), method=_tuple_error(Type, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000372, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.:(-)), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Ti, 1} where Ti<:Integer), Int64}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273355ac0)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.:(-)), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Ti, 1} where Ti<:Integer), Int64}, Tuple{Base.OneTo{Int64}}}, sparams=svec(typeof(Base.:(-))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R} where var"#s175"<:Tuple{Array{R, 1} where R}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a7d33680)[Core.MethodMatch(spec_types=Tuple{Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R} where var"#s175"<:Tuple{Array{R, 1} where R}, Int64}, sparams=svec(var"#s175"<:Tuple{Array{R, 1} where R}), method=(::Base.var"#cvt1#convert##0"{T, x})(Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000376, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), GenericMemoryRef{:not_atomic, T, Core.AddrSpace{Core}(0x00)} where T<:AbstractFloat, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228f7e9ea0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), GenericMemoryRef{:not_atomic, T, Core.AddrSpace{Core}(0x00)} where T<:AbstractFloat, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{2}, typeof(SparseMatricesCOO.replace_if_minusinf), Tuple{LinearAlgebra.Adjoint{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where Float64<:T<:Real, Float64}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742282cb65a0)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{2}, typeof(SparseMatricesCOO.replace_if_minusinf), Tuple{LinearAlgebra.Adjoint{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where Float64<:T<:Real, Float64}, Nothing}, sparams=svec(typeof(SparseMatricesCOO.replace_if_minusinf)), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(<)), Ptr{T} where T<:(QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2} where T where S where M1 where M2), Ptr{T} where T<:(QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2} where T where S where M1 where M2)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226e817be0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.:(<)), Ptr{T} where T<:(QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2} where T where S where M1 where M2), Ptr{T} where T<:(QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2} where T where S where M1 where M2)}, sparams=svec(), method=<(Ptr{T} where T, Ptr{T} where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000cbc, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.string), String, Real, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228b8944e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.string), String, Real, String}, sparams=svec(), method=string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003db1, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{LinearOperators.var"##_#1", Type, Type{LinearOperators.LinearOperator{_A, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where _A, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{T, Ti, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Ti<:Integer where T<:Real) where Tlow<:Real, Nothing, Nothing, Int64, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422712216a0)[Core.MethodMatch(spec_types=Tuple{LinearOperators.var"##_#1", Type, Type{LinearOperators.LinearOperator{_A, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where _A, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{T, Ti, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Ti<:Integer where T<:Real) where Tlow<:Real, Nothing, Nothing, Int64, Int64, Int64}, sparams=svec(_A, Int64, F<:(RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{T, Ti, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Ti<:Integer where T<:Real) where Tlow<:Real), Nothing, Nothing), method=var"#_#1"(Type, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, I, I, Bool, Bool, F, Ft, Fct, I, I, I) where {T, I<:Integer, F, Ft, Fct}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.methods), RipQP.var"#PreconditionerData##4#PreconditionerData##5"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Type{Tuple}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422aa6ac540)[Core.MethodMatch(spec_types=Tuple{typeof(Base.methods), RipQP.var"#PreconditionerData##4#PreconditionerData##5"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Type{Tuple}, Nothing}, sparams=svec(), method=methods(Any, Any, Union{Nothing, Base.AbstractSet{Module}, Tuple{Module}, AbstractArray{Module, N} where N}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000576, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._tuple_error), Type{var"#s175"} where var"#s175"<:Tuple{Base.Broadcast.Extruded{FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Number)}, Tuple{Base.Broadcast.Extruded{FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Number)}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273bfcb00)[Core.MethodMatch(spec_types=Tuple{typeof(Base._tuple_error), Type{var"#s175"} where var"#s175"<:Tuple{Base.Broadcast.Extruded{FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Number)}, Tuple{Base.Broadcast.Extruded{FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Number)}}, sparams=svec(), method=_tuple_error(Type, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000372, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Vararg{V, N}} where V where N where var"#s175"<:(Tuple{Vararg{_B, _A}} where _B where _A), Base.Val{x} where x}, limit=5), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(5,), mem=Memory{Any}(6, 0x74228f64e550)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Vararg{V, N}} where V where N where var"#s175"<:(Tuple{Vararg{_B, _A}} where _B where _A), Base.Val{3}}, sparams=svec(), method=ntuple(Any, Base.Val{3}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Vararg{V, N}} where V where N where var"#s175"<:(Tuple{Vararg{_B, _A}} where _B where _A), Base.Val{2}}, sparams=svec(), method=ntuple(Any, Base.Val{2}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Vararg{V, N}} where V where N where var"#s175"<:(Tuple{Vararg{_B, _A}} where _B where _A), Base.Val{1}}, sparams=svec(), method=ntuple(Any, Base.Val{1}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Vararg{V, N}} where V where N where var"#s175"<:(Tuple{Vararg{_B, _A}} where _B where _A), Base.Val{0}}, sparams=svec(), method=ntuple(Any, Base.Val{0}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Vararg{V, N}} where V where N where var"#s175"<:(Tuple{Vararg{_B, _A}} where _B where _A), Base.Val{x} where x}, sparams=svec(F<:(Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Vararg{V, N}} where V where N where var"#s175"<:(Tuple{Vararg{_B, _A}} where _B where _A)), x), method=ntuple(F, Base.Val{N}) where {F, N}, fully_covers=true), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000017e3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.not_sametype), Tuple{Any, Any}, Tuple{Any, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74228b9b8460)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.not_sametype), T, T} where T<:Tuple{Any, Any}, sparams=svec(T<:T<:Tuple{Any, Any}), method=not_sametype(T, T) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.not_sametype), Tuple{Any, Any}, Tuple{Any, Any}}, sparams=svec(), method=not_sametype(Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000061a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Nothing, typeof(Base.:(var"==")), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d508380)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Nothing, typeof(Base.:(var"==")), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Tuple{Base.OneTo{Int64}}}, sparams=svec(typeof(Base.:(var"=="))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{O} where O<:Real, Real}, limit=3), nothing, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{SparseArrays.CHOLMOD.Dense{_A}} where _A, SparseArrays.CHOLMOD.Dense{T} where T<:Union{Float32, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226f146860)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{SparseArrays.CHOLMOD.Dense{T}}, SparseArrays.CHOLMOD.Dense{T}} where T<:Union{Float32, Float64}, sparams=svec(T<:Union{Float32, Float64}), method=convert(Type{SparseArrays.CHOLMOD.Dense{T}}, SparseArrays.CHOLMOD.Dense{T}) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{SparseArrays.CHOLMOD.Dense{_A}} where _A, SparseArrays.CHOLMOD.Dense{T} where T<:Union{Float32, Float64}}, sparams=svec(_A, T<:Union{Float32, Float64}), method=convert(Type{SparseArrays.CHOLMOD.Dense{Tnew}}, SparseArrays.CHOLMOD.Dense{T}) where {Tnew, T}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009675, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._growend!), Array{R, 1} where R, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e5718a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._growend!), Array{R, 1} where R, Int64}, sparams=svec(), method=_growend!(Array{T, 1} where T, Integer), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000112f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eltype), Type{var"#s179"} where var"#s179"<:Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Float64}, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Float64, 1}}, Pair{Symbol, Array{Float64, 1}}, Pair{Symbol, Array{Float64, 1}}, Pair{Symbol, Array{Int64, 1}}, Vararg{Pair{Symbol, Array{Float64, 1}}, 4}}}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(6, 0x74228c5c24b0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.eltype), Type{Union{}}}, sparams=svec(), method=eltype(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.eltype), Type{var"#s179"} where var"#s179"<:Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Float64}, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Float64, 1}}, Pair{Symbol, Array{Float64, 1}}, Pair{Symbol, Array{Float64, 1}}, Pair{Symbol, Array{Int64, 1}}, Vararg{Pair{Symbol, Array{Float64, 1}}, 4}}}, sparams=svec(), method=eltype(Type{var"#s179"} where var"#s179"<:Tuple), fully_covers=true), #, #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001245, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{RipQP.LDLFactorizationData{T} where T}, LDLFactorizations.LDLFactorization{Float64, Int64, Int64, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228ca731a0)[Core.MethodMatch(spec_types=Tuple{Type{RipQP.LDLFactorizationData{T} where T}, LDLFactorizations.LDLFactorization{Float64, Int64, Int64, Int64}}, sparams=svec(Float64), method=(::Type{RipQP.LDLFactorizationData{T} where T})(LDLFactorizations.LDLFactorization{T, Int64, Int64, Int64}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core._typeof_captured_variable), Tuple{Tuple{Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T, LinearOperators.LinearOperator{_A, Int64, LinearOperators.var"#119#120", LinearOperators.var"#119#120", LinearOperators.var"#119#120", T} where T where _A}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228b402f60)[Core.MethodMatch(spec_types=Tuple{typeof(Core._typeof_captured_variable), Tuple{Tuple{Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T, LinearOperators.LinearOperator{_A, Int64, LinearOperators.var"#119#120", LinearOperators.var"#119#120", LinearOperators.var"#119#120", T} where T where _A}}}, sparams=svec(), method=_typeof_captured_variable(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000004a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(StaticArraysCore.tuple_svec), Type{S} where S<:(Tuple{var"#s7", var"#s8"} where var"#s7" where var"#s8")}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d46d600)[Core.MethodMatch(spec_types=Tuple{typeof(StaticArraysCore.tuple_svec), Type{S} where S<:(Tuple{var"#s7", var"#s8"} where var"#s7" where var"#s8")}, sparams=svec(S<:(Tuple{var"#s7", var"#s8"} where var"#s7" where var"#s8")), method=tuple_svec(Type{T}) where {T<:Tuple}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000968c, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._promote_typesubtract), Type{Pair{Symbol, Nothing}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a95ca820)[Core.MethodMatch(spec_types=Tuple{typeof(Base._promote_typesubtract), Type{Pair{Symbol, Nothing}}}, sparams=svec(), method=_promote_typesubtract(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000005e6, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Any, Array{R, 1} where R<:Real} where var"#s175"<:Tuple{Any, Array{R, 1} where R<:Real}, Base.Val{2}}, limit=5), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422869347c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Any, Array{R, 1} where R<:Real} where var"#s175"<:Tuple{Any, Array{R, 1} where R<:Real}, Base.Val{2}}, sparams=svec(), method=ntuple(Any, Base.Val{2}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000017db, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.ComposedFunction{Base.ComposedFunction{typeof(Base.identity), Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLPModel{T, S, Si}, Array{Int64, 1}, Int64}}}, Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}}} where Si where S where T, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74227395de80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.ComposedFunction{Base.ComposedFunction{typeof(Base.identity), Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLPModel{T, S, Si}, Array{Int64, 1}, Int64}}}, Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}}} where Si where S where T, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._foldl_impl), Base.BottomRF{typeof(Base.min)}, Base._InitialValue, Base.SubArray{Any, 1, P, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, false} where P<:(Array{T, 1} where T<:Real)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226ffbbfc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._foldl_impl), Base.BottomRF{typeof(Base.min)}, Base._InitialValue, Base.SubArray{Any, 1, P, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, false} where P<:(Array{T, 1} where T<:Real)}, sparams=svec(Base.BottomRF{typeof(Base.min)}), method=_foldl_impl(OP, Any, Any) where {OP}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000031dc, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), AbstractArray{T, 1} where Float64<:T<:Real, Base.Broadcast.Broadcasted{var"#s179", Nothing, typeof(Base.sqrt), var"#s179"} where var"#s179"<:Tuple{AbstractArray{T, 1} where Float64<:T<:Real} where var"#s179"<:Base.Broadcast.BroadcastStyle}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742283d862c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), AbstractArray{T, 1} where Float64<:T<:Real, Base.Broadcast.Broadcasted{var"#s179", Nothing, typeof(Base.sqrt), var"#s179"} where var"#s179"<:Tuple{AbstractArray{T, 1} where Float64<:T<:Real} where var"#s179"<:Base.Broadcast.BroadcastStyle}, sparams=svec(), method=combine_styles(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004832, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto_axcheck!), Array{T, 1} where T<:(QuadraticModels.PresolveOperation{T, _A} where T<:Real where _A), Array{QuadraticModels.PresolveOperation{T, _A}, 1} where T<:Real where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422838a11e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.copyto_axcheck!), Array{T, 1} where T<:(QuadraticModels.PresolveOperation{T, _A} where T<:Real where _A), Array{QuadraticModels.PresolveOperation{T, _A}, 1} where T<:Real where _A}, sparams=svec(), method=copyto_axcheck!(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012b7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.solver_name), RipQP.PreallocatedDataK2LDL{Float64, _A, F, M} where M<:AbstractArray{Float64, 2} where F<:(RipQP.LDLFactorizationData{T} where T) where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74227374e9e0)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.solver_name), RipQP.PreallocatedDataK2LDL{Float64, _A, F, M} where M<:AbstractArray{Float64, 2} where F<:(RipQP.LDLFactorizationData{T} where T) where _A}, sparams=svec(), method=solver_name(RipQP.PreallocatedDataK2LDL{T, S, F, M} where M<:AbstractArray{T, 2} where F where S where T<:Real), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{SparseArrays.SparseVector{Float64, Int64}}, Int64, Array{Int64, 1}, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a7ce4960)[Core.MethodMatch(spec_types=Tuple{Type{SparseArrays.SparseVector{Float64, Int64}}, Int64, Array{Int64, 1}, Array{Float64, 1}}, sparams=svec(Float64, Int64), method=(::Type{SparseArrays.SparseVector{Tv, Ti}})(Integer, Array{Ti, 1}, Array{Tv, 1}) where {Tv, Ti<:Integer}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009675, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.show_circular), Base.GenericIOBuffer{Memory{UInt8}}, Array{R, 1} where R<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74227376a280)[Core.MethodMatch(spec_types=Tuple{typeof(Base.show_circular), Base.GenericIOBuffer{Memory{UInt8}}, Array{R, 1} where R<:Real}, sparams=svec(), method=show_circular(IO, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000415d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:Array{Int64, 1}, Array{Int64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x742285e97ee0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Array{Int64, 1}}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:Array{Int64, 1}, Array{Int64, 1}}, sparams=svec(var"#s175"<:Array{Int64, 1}), method=convert(Type{T}, AbstractArray{T, N} where N where T) where {T<:(Array{T, N} where N where T)}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010dd, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Base.IteratorsMD.CartesianIndices{N, R} where R<:Tuple{Vararg{Base.OrdinalRange{Int64, Int64}, N}} where N, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x742289376520)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Base.IteratorsMD.CartesianIndices{0, R} where R<:Tuple{}, Any}, sparams=svec(), method=iterate(Base.IteratorsMD.CartesianIndices{0, R} where R<:Tuple{}, Any), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Base.IteratorsMD.CartesianIndices{N, R} where R<:Tuple{Vararg{Base.OrdinalRange{Int64, Int64}, N}} where N, Any}, sparams=svec(), method=iterate(Base.IteratorsMD.CartesianIndices{N, R} where R<:Tuple{Vararg{Base.OrdinalRange{Int64, Int64}, N}} where N, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004606, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), Base.BitArray{1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.imag), var"#s179"} where var"#s179"<:Tuple{Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64}}}, limit=1), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226f221d60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.copyto!), Base.BitArray{1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.imag), var"#s179"} where var"#s179"<:Tuple{Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64}}}, sparams=svec(), method=copyto!(AbstractArray{T, N} where N where T, Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048c4, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._fill!), Array{T, 1} where T<:Number, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d40e7c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._fill!), Array{T, 1}, Number} where T<:Number, sparams=svec(T), method=_fill!(Array{T, N} where N, T) where {T}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010af, 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, 0x7422747ab340)[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{typeof(Base.compute_offset1), Any, Any, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x74226f2708e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.compute_offset1), AbstractArray{T, 1} where T, Integer, Tuple{Base.ReshapedArray{T, N, A, Tuple{}} where A<:(Base.AbstractRange{T} where T) where N where T}}, sparams=svec(), method=compute_offset1(AbstractArray{T, 1} where T, Integer, Tuple{Base.ReshapedArray{T, N, A, Tuple{}} where A<:(Base.AbstractRange{T} where T) where N where T}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.compute_offset1), AbstractArray{T, 1} where T, Integer, Tuple{Base.AbstractRange{T} where T}}, sparams=svec(), method=compute_offset1(AbstractArray{T, 1} where T, Integer, Tuple{Base.AbstractRange{T} where T}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.compute_offset1), Any, Integer, Tuple}, sparams=svec(), method=compute_offset1(Any, Integer, Tuple), fully_covers=false), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003357, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{RipQP.var"##fd_refinement#117", Bool, typeof(RipQP.fd_refinement), RipQP.QM_FloatData{Float64, S, M1, M2} where M2<:Union{AbstractArray{Float64, 2}, LinearOperators.AbstractLinearOperator{Float64}} where M1<:Union{AbstractArray{Float64, 2}, LinearOperators.AbstractLinearOperator{Float64}} where S<:AbstractArray{Float64, 1}, RipQP.QM_IntData, RipQP.AbstractResiduals{Float64, S} where S, Array{Float64, 1}, RipQP.Point{Float64, S} where S, RipQP.IterData{Float64, S} where S, RipQP.Tolerances{Float64}, RipQP.DescentDirectionAllocs{Float64, S} where S, RipQP.PreallocatedDataK2LDL{Float64, _A, F, M} where M<:AbstractArray{Float64, 2} where F<:(RipQP.LDLFactorizationData{T} where T) where _A, RipQP.StartingPointData{Float64, _A} where _A, RipQP.Counters, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228359a020)[Core.MethodMatch(spec_types=Tuple{RipQP.var"##fd_refinement#117", Bool, typeof(RipQP.fd_refinement), RipQP.QM_FloatData{Float64, S, M1, M2} where M2<:Union{AbstractArray{Float64, 2}, LinearOperators.AbstractLinearOperator{Float64}} where M1<:Union{AbstractArray{Float64, 2}, LinearOperators.AbstractLinearOperator{Float64}} where S<:AbstractArray{Float64, 1}, RipQP.QM_IntData, RipQP.AbstractResiduals{Float64, S} where S, Array{Float64, 1}, RipQP.Point{Float64, S} where S, RipQP.IterData{Float64, S} where S, RipQP.Tolerances{Float64}, RipQP.DescentDirectionAllocs{Float64, S} where S, RipQP.PreallocatedDataK2LDL{Float64, _A, F, M} where M<:AbstractArray{Float64, 2} where F<:(RipQP.LDLFactorizationData{T} where T) where _A, RipQP.StartingPointData{Float64, _A} where _A, RipQP.Counters, Symbol}, sparams=svec(Float64), method=var"#fd_refinement#117"(Bool, typeof(RipQP.fd_refinement), RipQP.QM_FloatData{T, S, M1, M2} where M2 where M1 where S, RipQP.QM_IntData, RipQP.AbstractResiduals{T, S} where S, Array{T, 1}, RipQP.Point{T, S} where S, RipQP.IterData{T, S} where S, RipQP.Tolerances{T}, RipQP.DescentDirectionAllocs{T, S} where S, RipQP.PreallocatedData{T, S} where S, RipQP.StartingPointData{T, S} where S, RipQP.Counters, Symbol) where {T<:Real}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Tuple{Base.StepRange{var"#s179", Int64} where var"#s179"<:Signed}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742287fb2620)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Tuple{Base.StepRange{var"#s179", Int64} where var"#s179"<:Signed}, Int64}, sparams=svec(), method=getindex(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000669, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.grow_to!), Base.Dict{Symbol, Int64}, Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Float64}, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Float64, 1}}, Pair{Symbol, Array{Float64, 1}}, Pair{Symbol, Array{Float64, 1}}, Pair{Symbol, Array{Int64, 1}}, Vararg{Pair{Symbol, Array{Float64, 1}}, 4}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a97e7400)[Core.MethodMatch(spec_types=Tuple{typeof(Base.grow_to!), Base.Dict{Symbol, Int64}, Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Float64}, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Float64, 1}}, Pair{Symbol, Array{Float64, 1}}, Pair{Symbol, Array{Float64, 1}}, Pair{Symbol, Array{Int64, 1}}, Vararg{Pair{Symbol, Array{Float64, 1}}, 4}}, Int64}, sparams=svec(Symbol, Int64), method=grow_to!(Base.AbstractDict{K, V}, Any, Any) where {K, V}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001784, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"##mapfoldl#270", Int64, typeof(Base.mapfoldl), Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}, typeof(Base.add_sum), Base.Generator{Array{Int64, 1}, F} where F<:(NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLPModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422737d2520)[Core.MethodMatch(spec_types=Tuple{Base.var"##mapfoldl#270", Int64, typeof(Base.mapfoldl), Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}, typeof(Base.add_sum), Base.Generator{Array{Int64, 1}, F} where F<:(NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLPModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T)}, sparams=svec(), method=var"#mapfoldl#270"(Any, typeof(Base.mapfoldl), Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000031ff, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{ft} where ft<:Union{Float32, Float64}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228dc5d380)[Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Symbol}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000034c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), Array{Tv, 2} where Tv<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742284ed0da0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), Array{Tv, 2} where Tv<:Real}, sparams=svec(), method=size(Array{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001093, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.axes), Array{T, 1} where T<:Number}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d7fa360)[Core.MethodMatch(spec_types=Tuple{typeof(Base.axes), Array{T, 1} where T<:Number}, sparams=svec(), method=axes(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000122a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(var"==")), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742271d9e3e0)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(var"==")), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, 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{Type{BoundsError}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226cc8b2e0)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, 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{NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLPModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742289dd6c60)[Core.MethodMatch(spec_types=Tuple{NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLPModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T, Int64}, sparams=svec(), method=(::NLPModels.var"#jac_structure!##2#jac_structure!##3"{nlp, rows, var"#11#i"})(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096b0, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{LinearOperators.var"##_#2", Type, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where T, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##16#PreconditionerData##17"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real, Nothing, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742270f6b100)[Core.MethodMatch(spec_types=Tuple{LinearOperators.var"##_#2", Type, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where T, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##16#PreconditionerData##17"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real, Nothing, Nothing}, sparams=svec(T, Int64), method=var"#_#2"(Type, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, I, I, Bool, Bool, Any, Any, Any) where {T, I<:Integer}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Type{RipQP.var"#PreconditionerData##16#PreconditionerData##17"{RipQP.LDLFactorizationData{Tlow}}} where Tlow<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a997f6c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Type{RipQP.var"#PreconditionerData##16#PreconditionerData##17"{RipQP.LDLFactorizationData{Tlow}}} where Tlow<:Real, 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{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, typeof(Base.sqrt), Tuple{AbstractArray{Float64, 1}}, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228da950a0)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, typeof(Base.sqrt), Tuple{AbstractArray{Float64, 1}}, Any}, sparams=svec(typeof(Base.sqrt)), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{Nothing}, Tuple{Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742282c63180)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{Nothing}, Tuple{Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}}, Nothing}, sparams=svec(ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{Nothing}), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.print_to_string), Any, String, String, String, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273934860)[Core.MethodMatch(spec_types=Tuple{typeof(Base.print_to_string), Any, String, String, String, Any}, sparams=svec(), method=print_to_string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003dae, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{ReverseDiff.SpecialInstruction{F, I, O, C} where C where O where I where F}, typeof(Base.convert), ReverseDiff.TrackedReal{V, D, O} where O where D<:Real where V<:Real, ReverseDiff.TrackedReal{_A, _B, O} where O<:(ReverseDiff.TrackedArray{V, D, 1, VA, DA} where V where D where VA where DA) where _B<:Real where _A<:Real, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a7035d60)[Core.MethodMatch(spec_types=Tuple{Type{ReverseDiff.SpecialInstruction{F, I, O, C} where C where O where I where F}, typeof(Base.convert), ReverseDiff.TrackedReal{V, D, O} where O where D<:Real where V<:Real, ReverseDiff.TrackedReal{_A, _B, O} where O<:(ReverseDiff.TrackedArray{V, D, 1, VA, DA} where V where D where VA where DA) where _B<:Real where _A<:Real, Nothing}, sparams=svec(), method=(::Type{ReverseDiff.SpecialInstruction{F, I, O, C} where C where O where I where F})(Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._setindex!), Base.Dict{K, Any} where Symbol<:K<:Any, QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2} where M2 where M1 where S where T, Symbol, Int64, UInt8}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226dcf6400)[Core.MethodMatch(spec_types=Tuple{typeof(Base._setindex!), Base.Dict{K, Any} where Symbol<:K<:Any, QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2} where M2 where M1 where S where T, Symbol, Int64, UInt8}, sparams=svec(), method=_setindex!(Base.Dict{K, V} where V where K, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000034d7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(var"==")), Any, UInt64}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.merge), NamedTuple{(:x,), var"#s179"} where var"#s179"<:Tuple{Any}, NamedTuple{names, T} where T<:Tuple where names}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226f2bda60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.merge), NamedTuple{(:x,), var"#s179"} where var"#s179"<:Tuple{Any}, NamedTuple{(), T} where T<:Tuple}, sparams=svec(), method=merge(NamedTuple{names, T} where T<:Tuple where names, NamedTuple{(), T} where T<:Tuple), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.merge), NamedTuple{(:x,), var"#s179"} where var"#s179"<:Tuple{Any}, NamedTuple{names, T} where T<:Tuple where names}, sparams=svec((:x,), names), method=merge(NamedTuple{an, T} where T<:Tuple, NamedTuple{bn, T} where T<:Tuple) where {an, bn}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001a9e, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.one), Type{T} where T<:AbstractFloat}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(6, 0x74228f6f3ef0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.one), Type{Union{}}}, sparams=svec(), method=one(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.one), Type{T} where T<:AbstractFloat}, sparams=svec(T<:AbstractFloat), method=one(Type{T}) where {T<:Number}, fully_covers=true), #, #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000a81, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Nothing, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Base.Broadcast.Extruded{Array{Float64, 1}, Tuple{Bool}, Tuple{Int64}}, Float64}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Base.Broadcast.Extruded{Array{Float64, 1}, Tuple{Bool}, Tuple{Int64}}, Float64}}}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422869e9f60)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Nothing, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Base.Broadcast.Extruded{Array{Float64, 1}, Tuple{Bool}, Tuple{Int64}}, Float64}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Base.Broadcast.Extruded{Array{Float64, 1}, Tuple{Bool}, Tuple{Int64}}, Float64}}}, Tuple{Base.OneTo{Int64}}}, sparams=svec(typeof(Base.:(&))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(>)), Tuple{Array{Float64, 1}, Float64}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float64, 1}, Float64}}}}, Type{Bool}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228dd48100)[Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(>)), Tuple{Array{Float64, 1}, Float64}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float64, 1}, Float64}}}}, Type{Bool}}, sparams=svec(Bool), method=similar(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Type{T}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047d3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core._typeof_captured_variable), Tuple{Any, Base.RefValue{T} where T, AbstractArray{Float64, 1}, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228cf1fbe0)[Core.MethodMatch(spec_types=Tuple{typeof(Core._typeof_captured_variable), Tuple{Any, Base.RefValue{T} where T, AbstractArray{Float64, 1}, Float64}}, sparams=svec(), method=_typeof_captured_variable(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000004a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), RipQP.LLDLFactorizationData{T, F} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{T, Ti, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Ti<:Integer where T<:Real) where T, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742283de40c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), RipQP.LLDLFactorizationData{T, F} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{T, Ti, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Ti<:Integer where T<:Real) where T, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Array{Tv, 2} where Tv<:Real, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742284997700)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Array{Tv, 2} where Tv<:Real, Int64}, sparams=svec(), method=getindex(Array{T, N} where N where T, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000399, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{ft} where ft<:(SparseArrays.CHOLMOD.Factor{T, Ti} where Ti<:Union{Int32, Int64} where T<:Real), Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7422864994a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Bool}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000034c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.precond_name), RipQP.PreconditionerData{T, S} where S where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226e2eeda0)[ Core.MethodMatch(spec_types=Tuple{typeof(RipQP.precond_name), RipQP.LDLData{T, S, Tlow, Op, M, F} where F<:RipQP.FactorizationData{Tlow} where M<:Union{AbstractArray{T, 2}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where Op<:Union{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T, RipQP.LRPrecond{Op1, Op2} where Op2 where Op1}} where Tlow where S where T<:Real, sparams=svec(T<:Real, S, Tlow), method=precond_name(RipQP.LDLData{T, S, Tlow, Op, M, F} where F<:RipQP.FactorizationData{Tlow} where M<:Union{AbstractArray{T, 2}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where Op<:Union{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T, RipQP.LRPrecond{Op1, Op2} where Op2 where Op1}) where {T, S, Tlow}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(RipQP.precond_name), RipQP.PreconditionerData{T, S} where S where T<:Real}, sparams=svec(), method=precond_name(RipQP.PreconditionerData{T, S} where S where T<:Real), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.SubArray{_A, _B, P, I, false} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228f3c67c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.SubArray{_A, _B, P, I, false} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a82611e0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}}, sparams=svec(), method=Typeof(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000028, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setproperty!), LDLFactorizations.LDLFactorization{Tlow, Int64, Int64, Int64} where Tlow, Symbol, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742283ab3200)[Core.MethodMatch(spec_types=Tuple{typeof(Base.setproperty!), LDLFactorizations.LDLFactorization{Tlow, Int64, Int64, Int64} where Tlow, Symbol, Any}, sparams=svec(), method=setproperty!(Any, Symbol, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000284, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, Type{T} where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##16#PreconditionerData##17"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422730625c0)[Core.MethodMatch(spec_types=Tuple{Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, Type{T} where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##16#PreconditionerData##17"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real}, sparams=svec(T<:Real, Int64), method=(::Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T})(Type{T}, I, I, Bool, Bool, Any) where {T, I<:Integer}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core._typeof_captured_variable), Tuple{Base.RefValue{typeof(Base.:(<))}, AbstractArray{Float64, 1}, AbstractArray{Float64, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742283ed7320)[Core.MethodMatch(spec_types=Tuple{typeof(Core._typeof_captured_variable), Tuple{Base.RefValue{typeof(Base.:(<))}, AbstractArray{Float64, 1}, AbstractArray{Float64, 1}}}, sparams=svec(), method=_typeof_captured_variable(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000004a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), Any, AbstractArray{T, 1} where T, Base.Broadcast.Broadcasted{var"#s179", Nothing, typeof(RipQP.safe_boundary), var"#s179"} where var"#s179"<:Tuple{AbstractArray{T, 1} where T} where var"#s179"<:Base.Broadcast.BroadcastStyle}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228cf84d40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.Broadcast.BroadcastStyle, AbstractArray{T, 1} where T, Base.Broadcast.Broadcasted{var"#s179", Nothing, typeof(RipQP.safe_boundary), var"#s179"} where var"#s179"<:Tuple{AbstractArray{T, 1} where T} where var"#s179"<:Base.Broadcast.BroadcastStyle}, sparams=svec(), method=materialize!(Base.Broadcast.BroadcastStyle, Any, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048bf, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._firstslice), Base.AbstractUnitRange{T} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x742286b84560)[ Core.MethodMatch(spec_types=Tuple{typeof(Base._firstslice), Base.Slice{T} where T<:(Base.AbstractUnitRange{T} where T)}, sparams=svec(), method=_firstslice(Base.Slice{T} where T<:(Base.AbstractUnitRange{T} where T)), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base._firstslice), Base.OneTo{T} where T<:Integer}, sparams=svec(), method=_firstslice(Base.OneTo{T} where T<:Integer), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base._firstslice), Base.AbstractUnitRange{T} where T}, sparams=svec(), method=_firstslice(Any), fully_covers=true), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000059ee, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{ADNLPModels.var"##ADModelBackend#5", Symbol, Bool, Bool, Any, Any, Any, Any, Any, Any, Any, Base.Pairs{Symbol, _A, I, A} where A<:(NamedTuple{names, T} where T<:Tuple where names) where I<:Tuple{Vararg{Symbol}} where _A, Type{ADNLPModels.ADModelBackend{GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS} where HBLS where JBLS where JtvBLS where JvBLS where HvBLS where GHJ where HB where JB where JtvB where JvB where HvB where GB}, Integer, SolverTest.var"#f#98", Integer, ADNLPModels.var"#c!#304"{SolverTest.var"#c#99"}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226fef3bc0)[Core.MethodMatch(spec_types=Tuple{ADNLPModels.var"##ADModelBackend#5", Symbol, Bool, Bool, Any, Any, Any, Any, Any, Any, Any, Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where T<:Tuple{Vararg{Any, N}} where names where N where V, Type{ADNLPModels.ADModelBackend{GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS} where HBLS where JBLS where JtvBLS where JvBLS where HvBLS where GHJ where HB where JB where JtvB where JvB where HvB where GB}, Integer, SolverTest.var"#f#98", Integer, ADNLPModels.var"#c!#304"{SolverTest.var"#c#99"}}, sparams=svec(), method=var"#ADModelBackend#5"(Symbol, Bool, Bool, Any, Any, Any, Any, Any, Any, Any, Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where T<:Tuple{Vararg{Any, N}} where names where N where V, Type{ADNLPModels.ADModelBackend{GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS} where HBLS where JBLS where JtvBLS where JvBLS where HvBLS where GHJ where HB where JB where JtvB where JvB where HvB where GB}, Integer, Any, Integer, Any), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096b3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.methods), RipQP.var"#PreconditionerData##14#PreconditionerData##15"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Type{Tuple}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a9ed2be0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.methods), RipQP.var"#PreconditionerData##14#PreconditionerData##15"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Type{Tuple}, Nothing}, sparams=svec(), method=methods(Any, Any, Union{Nothing, Base.AbstractSet{Module}, Tuple{Module}, AbstractArray{Module, N} where N}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000576, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, Type{T} where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Int64, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Tf<:Real) where Tlow<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a7103040)[Core.MethodMatch(spec_types=Tuple{Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, Type{T} where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Int64, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Tf<:Real) where Tlow<:Real}, sparams=svec(T<:Real, Int64), method=(::Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T})(Type{T}, I, I, Bool, Bool, Any) where {T, I<:Integer}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T}, NLPModels.NLPModelMeta{Float64, Array{Float64, 1}}, NLPModels.Counters, ADNLPModels.ADModelBackend{_A, _B, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, _C, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend} where _C where _B where _A, SolverTest.var"#22#23", Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 1}, ADNLPModels.var"#297#298"{Type{Float64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228beaba20)[Core.MethodMatch(spec_types=Tuple{Type{ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T}, NLPModels.NLPModelMeta{Float64, Array{Float64, 1}}, NLPModels.Counters, ADNLPModels.ADModelBackend{_A, _B, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, _C, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend} where _C where _B where _A, SolverTest.var"#22#23", Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 1}, ADNLPModels.var"#297#298"{Type{Float64}}}, sparams=svec(Float64, Array{Float64, 1}, Array{Int64, 1}), method=(::Type{ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T})(NLPModels.NLPModelMeta{T, S}, NLPModels.Counters, ADNLPModels.ADModelBackend{GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS} where HBLS where JBLS where JtvBLS where JvBLS where HvBLS where GHJ where HB where JB where JtvB where JvB where HvB where GB, Any, Si, Si, S, Any) where {T, S, Si}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096b3, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IteratorSize}, Type{Base.LogicalIndex{T, A}} where A<:(AbstractArray{Bool, N} where N) where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x742285247e60)[ Core.MethodMatch(spec_types=Tuple{Type{Base.IteratorSize}, Type{Base.LogicalIndex{T, A}} where A<:(AbstractArray{Bool, N} where N) where T}, sparams=svec(1), method=(::Type{Base.IteratorSize})(Type{var"#s65"} where var"#s65"<:(AbstractArray{var"#s32", N} where var"#s32")) where {N}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000044a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), Any, Any, Base.RefValue{typeof(Base.:(*))}, Any, Array{T, N} where N where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226e5fec20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Base.Broadcast.BroadcastStyle, F, Base.RefValue{typeof(Base.:(*))}, Any, Array{T, N} where N where T} where F, sparams=svec(F<:F), method=broadcasted(Base.Broadcast.BroadcastStyle, F, Any...) where {F}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Any, Any, Base.RefValue{typeof(Base.:(*))}, Any, Array{T, N} where N where T}, sparams=svec(F), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000495a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:(LinearOperators.LinearOperator{_A, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where _A), LinearOperators.LinearOperator{_A, Int64, F, Ft, Fct, T} where T where Fct<:(NLPModels.var"#27#28"{var"#s179", ADNLPModels.ADNLPModel{T, S, Si}, var"#s179", var"#s179", typeof(Base.:(*)), typeof(Base.:(+))} where var"#s179"<:AbstractArray{T, 1} where T where var"#s179"<:AbstractArray{T, 1} where T where Si where S<:AbstractArray{T, 1} where T where var"#s179"<:Real) where Ft<:(NLPModels.var"#27#28"{var"#s179", ADNLPModels.ADNLPModel{T, S, Si}, var"#s179", var"#s179", typeof(Base.:(*)), typeof(Base.:(+))} where var"#s179"<:AbstractArray{T, 1} where T where var"#s179"<:AbstractArray{T, 1} where T where Si where S<:AbstractArray{T, 1} where T where var"#s179"<:Real) where F<:(NLPModels.var"#27#28"{var"#s179", ADNLPModels.ADNLPModel{T, S, Si}, var"#s179", var"#s179", typeof(Base.:(*)), typeof(Base.:(+))} where var"#s179"<:AbstractArray{T, 1} where T where var"#s179"<:AbstractArray{T, 1} where T where Si where S<:AbstractArray{T, 1} where T where var"#s179"<:Real) where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226f27cd20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, LinearOperators.LinearOperator{_A, Int64, F, Ft, Fct, T} where T where Fct<:(NLPModels.var"#27#28"{var"#s179", ADNLPModels.ADNLPModel{T, S, Si}, var"#s179", var"#s179", typeof(Base.:(*)), typeof(Base.:(+))} where var"#s179"<:AbstractArray{T, 1} where T where var"#s179"<:AbstractArray{T, 1} where T where Si where S<:AbstractArray{T, 1} where T where var"#s179"<:Real) where Ft<:(NLPModels.var"#27#28"{var"#s179", ADNLPModels.ADNLPModel{T, S, Si}, var"#s179", var"#s179", typeof(Base.:(*)), typeof(Base.:(+))} where var"#s179"<:AbstractArray{T, 1} where T where var"#s179"<:AbstractArray{T, 1} where T where Si where S<:AbstractArray{T, 1} where T where var"#s179"<:Real) where F<:(NLPModels.var"#27#28"{var"#s179", ADNLPModels.ADNLPModel{T, S, Si}, var"#s179", var"#s179", typeof(Base.:(*)), typeof(Base.:(+))} where var"#s179"<:AbstractArray{T, 1} where T where var"#s179"<:AbstractArray{T, 1} where T where Si where S<:AbstractArray{T, 1} where T where var"#s179"<:Real) where _A}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, LinearOperators.LinearOperator{_A, Int64, F, Ft, Fct, T} where T where Fct<:(NLPModels.var"#27#28"{var"#s179", ADNLPModels.ADNLPModel{T, S, Si}, var"#s179", var"#s179", typeof(Base.:(*)), typeof(Base.:(+))} where var"#s179"<:AbstractArray{T, 1} where T where var"#s179"<:AbstractArray{T, 1} where T where Si where S<:AbstractArray{T, 1} where T where var"#s179"<:Real) where Ft<:(NLPModels.var"#27#28"{var"#s179", ADNLPModels.ADNLPModel{T, S, Si}, var"#s179", var"#s179", typeof(Base.:(*)), typeof(Base.:(+))} where var"#s179"<:AbstractArray{T, 1} where T where var"#s179"<:AbstractArray{T, 1} where T where Si where S<:AbstractArray{T, 1} where T where var"#s179"<:Real) where F<:(NLPModels.var"#27#28"{var"#s179", ADNLPModels.ADNLPModel{T, S, Si}, var"#s179", var"#s179", typeof(Base.:(*)), typeof(Base.:(+))} where var"#s179"<:AbstractArray{T, 1} where T where var"#s179"<:AbstractArray{T, 1} where T where Si where S<:AbstractArray{T, 1} where T where var"#s179"<:Real) where _A} where T<:(LinearOperators.LinearOperator{_A, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where _A), sparams=svec(T), method=convert(Type{T}, T) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000034c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isbitstype), Type{Array{Base.Complex{T}, 1}} where T<:Union{Float32, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228c275420)[Core.MethodMatch(spec_types=Tuple{typeof(Base.isbitstype), Type{Array{Base.Complex{T}, 1}} where T<:Union{Float32, Float64}}, sparams=svec(), method=isbitstype(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000503, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Base.MappingRF{Base.var"#_bool##0#_bool##1"{typeof(SparseArrays._isnotzero)}, Base.BottomRF{typeof(Base.add_sum)}}, Int64, Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742284a56f00)[Core.MethodMatch(spec_types=Tuple{Base.MappingRF{Base.var"#_bool##0#_bool##1"{typeof(SparseArrays._isnotzero)}, Base.BottomRF{typeof(Base.add_sum)}}, Int64, Real}, sparams=svec(), method=(::Base.MappingRF{F, T})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000031eb, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.ismutable), SparseArrays.CHOLMOD.Dense{Tv} where Tv<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a7e7c720)[Core.MethodMatch(spec_types=Tuple{typeof(Base.ismutable), SparseArrays.CHOLMOD.Dense{Tv} where Tv<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}}, sparams=svec(), method=ismutable(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000004f9, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._promote_typesubtract), Type{Symbol}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a71680e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._promote_typesubtract), Type{Symbol}}, sparams=svec(), method=_promote_typesubtract(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000005e6, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.print_to_string), String, Type, String, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74227379f300)[Core.MethodMatch(spec_types=Tuple{typeof(Base.print_to_string), String, Type, String, String}, sparams=svec(), method=print_to_string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003dae, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), SparseMatrixColorings.AdjacencyGraph{T, has_diagonal} where has_diagonal where T<:Integer, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a7c157a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), SparseMatrixColorings.AdjacencyGraph{T, has_diagonal} where has_diagonal where T<:Integer, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), FillArrays.Fill{Float64, 1, Tuple{Base.OneTo{Int64}}}, Any, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422742f3fa0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), FillArrays.Fill{Float64, 1, Tuple{Base.OneTo{Int64}}}, Any, Int64}, sparams=svec(Float64, 1), method=setindex!(FillArrays.AbstractFill{T, N, Axes} where Axes, Any, Vararg{Integer, N}) where {T, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009681, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._getindex), Tuple{Base.Broadcast.Extruded{T, K, D} where D<:Tuple where K<:Tuple where T<:(Base.SubArray{T, 1, P, I, L} where L where I where P where T), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Number)}, LinearAlgebra.BandIndex}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d344240)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._getindex), Tuple{Base.Broadcast.Extruded{T, K, D} where D<:Tuple where K<:Tuple where T<:(Base.SubArray{T, 1, P, I, L} where L where I where P where T), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Number)}, LinearAlgebra.BandIndex}, sparams=svec(), method=_getindex(Tuple, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000489a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.merge), NamedTuple{(:x0,), var"#s179"} where var"#s179"<:Tuple{Array{_A, 1} where _A}, NamedTuple{(), Tuple{}}}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74228cece160)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.merge), NamedTuple{(:x0,), var"#s179"} where var"#s179"<:Tuple{Array{_A, 1} where _A}, NamedTuple{(), Tuple{}}}, sparams=svec(), method=merge(NamedTuple{names, T} where T<:Tuple where names, NamedTuple{(), T} where T<:Tuple), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001a9e, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.methods), RipQP.var"#PreconditionerData##14#PreconditionerData##15"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}, Type{Tuple}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228ee851a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.methods), RipQP.var"#PreconditionerData##14#PreconditionerData##15"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}, Type{Tuple}, Nothing}, sparams=svec(), method=methods(Any, Any, Union{Nothing, Base.AbstractSet{Module}, Tuple{Module}, AbstractArray{Module, N} where N}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000576, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), JSOSolvers.TronSolver{T, V, _C, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}} where S where Fct where Ft where F where I<:Integer where S where Fct where Ft where F where I<:Integer where _C<:Krylov.KrylovWorkspace{T, T, V} where V<:AbstractArray{T, 1} where T<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422aa6af1e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), JSOSolvers.TronSolver{T, V, _C, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}} where S where Fct where Ft where F where I<:Integer where S where Fct where Ft where F where I<:Integer where _C<:Krylov.KrylovWorkspace{T, T, V} where V<:AbstractArray{T, 1} where T<:Real, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.preprocess), Nothing, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(-)), var"#s179"} where var"#s179"<:Tuple{Array{Ti, 1} where Ti<:Integer, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273108700)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.preprocess), Nothing, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(-)), var"#s179"} where var"#s179"<:Tuple{Array{Ti, 1} where Ti<:Integer, Int64}}, sparams=svec(), method=preprocess(Any, Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048ca, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Array{Int64, 1}, Real} where var"#s175"<:Tuple{Array{Int64, 1}, Real}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226c832c20)[Core.MethodMatch(spec_types=Tuple{Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Array{Int64, 1}, Real} where var"#s175"<:Tuple{Array{Int64, 1}, Real}, Int64}, sparams=svec(var"#s175"<:Tuple{Array{Int64, 1}, Real}), method=(::Base.var"#cvt1#convert##0"{T, x})(Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000376, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Base.Broadcast.Broadcasted{Nothing, Axes, F, Args} where Args<:Tuple where F where Axes}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float64, 1}, Float64}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float64, 1}, Float64}}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742286a992e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Base.Broadcast.Broadcasted{Nothing, Axes, F, Args} where Args<:Tuple where F where Axes}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float64, 1}, Float64}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float64, 1}, Float64}}}}}, sparams=svec(Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float64, 1}, Float64}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float64, 1}, Float64}}}), method=convert(Type{Base.Broadcast.Broadcasted{NewStyle, Axes, F, Args} where Args<:Tuple where F where Axes}, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where var"#s677") where {NewStyle, Axes, F, Args}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047d1, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.RefValue{typeof(Base.min)}, AbstractArray{T, 1} where T, AbstractArray{T, N} where N where T}}, UInt64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a7d47bc0)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.RefValue{typeof(Base.min)}, AbstractArray{T, 1} where T, AbstractArray{T, N} where N where T}}, UInt64}, sparams=svec(), method=(::Type{MethodError})(Any, Any, UInt64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000009c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.maximum), Base.SubArray{Any, 1, P, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, false} where P<:(Array{T, 1} where T<:Real)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226d08b360)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.maximum), Base.SubArray{Any, 1, P, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, false} where P<:(Array{T, 1} where T<:Real)}, sparams=svec(), method=maximum(AbstractArray{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000005a3c, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), Array{Tf, 1} where Tf<:Number, Number, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74228b9abba0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Array{Tf, 1} where Tf<:Number, Number, Int64}, sparams=svec(Tf<:Number), method=setindex!(Array{T, N} where N, Any, Int64) where {T}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001117, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:Tuple{Real}, Tuple{Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x74226ec124a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Tuple{Real}}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, Tuple{Real}} where T<:Tuple{Real}, sparams=svec(T<:Tuple), method=convert(Type{T}, T) where {T<:Tuple}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:Tuple{Real}, Tuple{Real}}, sparams=svec(1, var"#s175"<:Tuple{Real}), 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{typeof(Base.not_sametype), Tuple{Signed, Signed}, Tuple{Any, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7422aa48cb60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.not_sametype), T, T} where T<:Tuple{Signed, Signed}, sparams=svec(T<:T<:Tuple{Signed, Signed}), method=not_sametype(T, T) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.not_sametype), Tuple{Signed, Signed}, Tuple{Any, Any}}, sparams=svec(), method=not_sametype(Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000061a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.typeintersect), Type{Tuple{Any, Any}}, Type{var"#s175"} where var"#s175"<:Tuple{AbstractArray{Float64, 1}, AbstractArray{Float64, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742283451fa0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.typeintersect), Type{Tuple{Any, Any}}, Type{var"#s175"} where var"#s175"<:Tuple{AbstractArray{Float64, 1}, AbstractArray{Float64, 1}}}, sparams=svec(), method=typeintersect(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000527, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.solver_name), RipQP.PreallocatedData{Float64, S} where S<:AbstractArray{Float64, 1}}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Type{Tuple{Pair{Symbol, Nothing}, Pair{Symbol, Array{QuadraticModels.PresolveOperation{Float64, Array{Float64, 1}}, 1}}}}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a944c9e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Type{Tuple{Pair{Symbol, Nothing}, Pair{Symbol, Array{QuadraticModels.PresolveOperation{Float64, Array{Float64, 1}}, 1}}}}, 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{LinearAlgebra.Diagonal{T, V} where V<:AbstractArray{T, 1} where T}, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), LinearAlgebra.Diagonal{T, V} where V<:Array{T, 1} where T<:Real, LinearAlgebra.BandIndex}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228ec0c1e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), LinearAlgebra.Diagonal{T, V} where V<:Array{T, 1} where T<:Real, LinearAlgebra.BandIndex}, sparams=svec(), method=getindex(LinearAlgebra.Diagonal{T, V} where V<:AbstractArray{T, 1} where T, LinearAlgebra.BandIndex), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000008b26, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.RefValue{typeof(Base.:(&))}, Any, Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226dfef8c0)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.RefValue{typeof(Base.:(&))}, Any, Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}}}, sparams=svec(), method=(::Type{MethodError})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000009d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Ti, 1} where Ti<:Integer), Int64}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742272c488c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Ti, 1} where Ti<:Integer), Int64}, Int64}, sparams=svec(), method=getindex(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000669, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.string), String, Type{A} where A<:(StaticArraysCore.StaticArray{Tuple{var"#s2"}, Float64, 1} where var"#s2"), String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d62c680)[Core.MethodMatch(spec_types=Tuple{typeof(Base.string), String, Type{A} where A<:(StaticArraysCore.StaticArray{Tuple{var"#s2"}, Float64, 1} where var"#s2"), String}, sparams=svec(), method=string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003db1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.length), Array{_A, 2} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742285a29aa0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.length), Array{_A, 2} where _A}, sparams=svec(_A), method=length(Array{T, 2}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000030d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.SubString{T}} where T<:AbstractString, AbstractString, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422899fc3c0)[Core.MethodMatch(spec_types=Tuple{Type{Base.SubString{T}}, T, Int64, Int64} where T<:AbstractString, sparams=svec(T<:AbstractString), method=(::Type{Base.SubString{T}})(T, Int64, Int64) where {T<:AbstractString}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000375d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(-)), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74228a73eaa0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(-)), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R}}, sparams=svec(), method=instantiate(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004803, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{LinearOperators.var"##_#2", typeof(DataType), Type{LinearOperators.LinearOperator{Float64, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##12#PreconditionerData##13"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Nothing, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742289f01600)[Core.MethodMatch(spec_types=Tuple{LinearOperators.var"##_#2", typeof(DataType), Type{LinearOperators.LinearOperator{Float64, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##12#PreconditionerData##13"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Nothing, Nothing}, sparams=svec(Float64, Int64), method=var"#_#2"(Type, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, I, I, Bool, Bool, Any, Any, Any) where {T, I<:Integer}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.maxintfloat), Type{Float32}, Type{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228697c5a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.maxintfloat), Type{Float32}, Type{Int64}}, sparams=svec(Float32, Int64), method=maxintfloat(Type{S}, Type{T}) where {S<:AbstractFloat, T<:Integer}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000005658, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real)}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228afec6e0)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real)}, 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.string), String, Any, String, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228c8e9cc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.string), String, Any, String, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, sparams=svec(), method=string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003db1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.abs), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R} where var"#s179"<:Tuple, Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228f568240)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.abs), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R} where var"#s179"<:Tuple, Tuple}, sparams=svec(), method=_axes(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047da, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), Base.RefValue{T} where T, AbstractArray{T, N} where N where T, Float64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742283323380)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), Base.RefValue{T} where T, AbstractArray{T, N} where N where T, Float64}, sparams=svec(), method=combine_styles(Any, Any, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004833, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{LinearAlgebra.BandIndex}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228ec1bf60)[Core.MethodMatch(spec_types=Tuple{Type{LinearAlgebra.BandIndex}, Int64, Int64}, sparams=svec(), method=(::Type{LinearAlgebra.BandIndex})(Int64, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000007abb, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:(RipQP.Regularization{Tlow} where Tlow<:Real), RipQP.Regularization{T} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x74226e5cece0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, RipQP.Regularization{T} where T<:Real}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{RipQP.Regularization{T}}, RipQP.Regularization{T0}} where T0<:Real where T<:Real, sparams=svec(T<:Real, T0<:Real), method=convert(Type{RipQP.Regularization{T}}, RipQP.Regularization{T0}) where {T<:Real, T0<:Real}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, RipQP.Regularization{T} where T<:Real} where T<:(RipQP.Regularization{Tlow} where Tlow<:Real), sparams=svec(T), method=convert(Type{T}, T) where {T}, fully_covers=false), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), RipQP.RipQPDoubleParameters{Float64, SP1, SP2, SM1, SM2} where SM2<:RipQP.SolveMethod where SM1<:RipQP.SolveMethod where SP2<:RipQP.SolverParams{Float64} where SP1<:(RipQP.SolverParams{T} where T), Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74227395cb00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), RipQP.RipQPDoubleParameters{Float64, SP1, SP2, SM1, SM2} where SM2<:RipQP.SolveMethod where SM1<:RipQP.SolveMethod where SP2<:RipQP.SolverParams{Float64} where SP1<:(RipQP.SolverParams{T} where T), Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{QuadraticModels.Row{T} where T, Int64}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a705a760)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{QuadraticModels.Row{T} where T, Int64}, Int64, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000689, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eltype), Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Float64}, Pair{Symbol, _A} where _A}}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228f5cd4c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.eltype), Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Float64}, Pair{Symbol, _A} where _A}}, sparams=svec(), method=eltype(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001246, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{StaticArraysCore.Size{S} where S}, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unwrap_composed), Base.ComposedFunction{Base.ComposedFunction{typeof(Base.identity), Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLPModel{T, S, Si}, Array{Int64, 1}, Int64}}}, Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}}} where Si where S where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74227395d180)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unwrap_composed), Base.ComposedFunction{Base.ComposedFunction{typeof(Base.identity), Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLPModel{T, S, Si}, Array{Int64, 1}, Int64}}}, Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}}} where Si where S where T}, sparams=svec(), method=unwrap_composed(Base.ComposedFunction{O, I} where I where O), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c29, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.vcat), Array{Ti, 1} where Ti<:Integer, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(19, 0x742286bca960)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.vcat), Vararg{Array{Int64, 1}, 4}}, sparams=svec(Int64), method=vcat(Array{T, 1}...) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.vcat), Array{Ti, 1} where Ti<:Integer, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}}, sparams=svec(), method=vcat((Array{T, 1} where T)...), fully_covers=true), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000011b3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseArrays.nonzeros), SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742283d56480)[Core.MethodMatch(spec_types=Tuple{typeof(SparseArrays.nonzeros), SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv}, sparams=svec(), method=nonzeros(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009744, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{SolverCore.var"##GenericExecutionStats#7", Symbol, Array{Float64, 1}, Float64, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Float64, Base.Dict{Symbol, Union{Nothing, Array{QuadraticModels.PresolveOperation{Float64, Array{Float64, 1}}, 1}}}, Type{SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T}, QuadraticModels.QuadraticModel{Float64, Array{Float64, 1}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d91a500)[Core.MethodMatch(spec_types=Tuple{SolverCore.var"##GenericExecutionStats#7", Symbol, Array{Float64, 1}, Float64, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Float64, Base.Dict{Symbol, Union{Nothing, Array{QuadraticModels.PresolveOperation{Float64, Array{Float64, 1}}, 1}}}, Type{SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T}, QuadraticModels.QuadraticModel{Float64, Array{Float64, 1}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}}}, sparams=svec(Float64, Array{Float64, 1}, Array{Float64, 1}, Union{Nothing, Array{QuadraticModels.PresolveOperation{Float64, Array{Float64, 1}}, 1}}), method=var"#GenericExecutionStats#7"(Symbol, S, T, T, T, S, V, V, Int64, Real, Base.Dict{Symbol, Tsp}, Type{SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T}, NLPModels.AbstractNLPModel{T, S}) where {T, S, V, Tsp}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096bd, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), Array{_A, 1} where _A, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R, Array{R, 1} where R}}, limit=1), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x742289463920)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.copyto!), Array{_A, 1} where _A, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R, Array{R, 1} where R}}, sparams=svec(), method=copyto!(AbstractArray{T, N} where N where T, Base.Broadcast.Broadcasted{Nothing, Axes, F, Args} where Args<:Tuple where F where Axes), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048d0, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{ForwardDiff.Dual{_A, Bool, 1}} where _A, Bool, ForwardDiff.Partials{1, Bool}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a8f653a0)[Core.MethodMatch(spec_types=Tuple{Type{ForwardDiff.Dual{_A, Bool, 1}} where _A, Bool, ForwardDiff.Partials{1, Bool}}, sparams=svec(_A, Bool, 1), method=(::Type{ForwardDiff.Dual{T, V, N}})(V, ForwardDiff.Partials{N, V}) where {T, V, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009697, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._getindex), Base.IndexLinear, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(<=)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228aed2c40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._getindex), Base.IndexLinear, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(<=)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Int64}, sparams=svec(), method=_getindex(Base.IndexStyle, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000487e, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ReverseDiff.value), ReverseDiff.TrackedReal{V, D, O} where O where D<:Real where V<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742285fe39e0)[Core.MethodMatch(spec_types=Tuple{typeof(ReverseDiff.value), ReverseDiff.TrackedReal{V, D, O} where O where D<:Real where V<:Real}, sparams=svec(), method=value(ReverseDiff.TrackedReal{V, D, O} where O where D<:Real where V<:Real), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(!=)), Type, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74228de332e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.:(!=)), Type, Type}, sparams=svec(), method=!=(Type, Type), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.:(!=)), Type, Any}, sparams=svec(), method=!=(Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000bd1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Sort._hi), Array{Ti, 1} where Ti<:Integer, Base.Order.ForwardOrdering, NamedTuple{(:lo, :hi, :legacy_dispatch_entry), var"#s179"} where var"#s179"<:Tuple{Integer, Integer, Base.Sort.InsertionSortAlg}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742274877fc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Sort._hi), Array{Ti, 1} where Ti<:Integer, Base.Order.ForwardOrdering, NamedTuple{(:lo, :hi, :legacy_dispatch_entry), var"#s179"} where var"#s179"<:Tuple{Integer, Integer, Base.Sort.InsertionSortAlg}}, sparams=svec(), method=_hi(Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000005bfa, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.any), Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.isreal)}, Base.Generator{_A, F} where F<:(LinearAlgebra.var"#Symmetric##0#Symmetric##1"{LinearAlgebra.Hermitian{T, S}} where S<:(AbstractArray{var"#s4711", 2} where var"#s4711"<:T) where T) where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e5a0d20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.any), Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.isreal)}, Base.Generator{_A, F} where F<:(LinearAlgebra.var"#Symmetric##0#Symmetric##1"{LinearAlgebra.Hermitian{T, S}} where S<:(AbstractArray{var"#s4711", 2} where var"#s4711"<:T) where T) where _A}, sparams=svec(), method=any(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001ad0, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(>)), Tuple{Array{Float64, 1}, Float64}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), Tuple{Array{Float64, 1}, Float64}}}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), Tuple{Array{Float64, 1}, Array{Float64, 1}}}}}, Type{Bool}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228b22fa60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(>)), Tuple{Array{Float64, 1}, Float64}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), Tuple{Array{Float64, 1}, Float64}}}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), Tuple{Array{Float64, 1}, Array{Float64, 1}}}}}, Type{Bool}, Tuple{Base.OneTo{Int64}}}, sparams=svec(1), method=similar(Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{N}, Axes, F, Args} where Args<:Tuple where F where Axes, Type{Bool}, Any) where {N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047d5, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.write_system), RipQP.SystemWrite, Any, AbstractArray{Float64, 1}, Symbol, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228bc46ec0)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.write_system), RipQP.SystemWrite, LinearAlgebra.Symmetric{Float64, SparseArrays.SparseMatrixCSC{Float64, Int64}}, Array{Float64, 1}, Symbol, Int64}, sparams=svec(Float64), method=write_system(RipQP.SystemWrite, LinearAlgebra.Symmetric{T, SparseArrays.SparseMatrixCSC{T, Int64}}, Array{T, 1}, Symbol, Int64) where {T<:Real}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._str_sizehint), Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422869fb580)[Core.MethodMatch(spec_types=Tuple{typeof(Base._str_sizehint), Integer}, sparams=svec(), method=_str_sizehint(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003dac, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.real), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64})}, Type}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228cba0180)[Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.real), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64})}, Type}, sparams=svec(T), method=similar(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Type{T}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047d3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.length), Tuple{Pair{Symbol, Nothing}, Pair{Symbol, Array{QuadraticModels.PresolveOperation{T, _A}, 1}} where _A where T<:Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d63f300)[Core.MethodMatch(spec_types=Tuple{typeof(Base.length), Tuple{Pair{Symbol, Nothing}, Pair{Symbol, Array{QuadraticModels.PresolveOperation{T, _A}, 1}} where _A where T<:Real}}, sparams=svec(), method=length(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000664, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.throw_boundserror), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(var"==")), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d0f5fe0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.throw_boundserror), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(var"==")), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Tuple{Int64}}, sparams=svec(), method=throw_boundserror(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000310, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.to_indices), Array{_A, 1} where _A, Tuple{Array{Int64, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x742288f469e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.to_indices), Array{_A, 1} where _A, Tuple{Array{Int64, 1}}}, sparams=svec(), method=to_indices(Any, Tuple{Any}), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000fd7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.update_regu_trycatch!), RipQP.Regularization{Tlow} where Tlow, RipQP.Counters}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228489bd00)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.update_regu_trycatch!), RipQP.Regularization{Tlow} where Tlow, RipQP.Counters}, sparams=svec(Tlow), method=update_regu_trycatch!(RipQP.Regularization{T}, RipQP.Counters) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.throw_checksize_error), Array{_A, 1} where _A, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e06ac80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.throw_checksize_error), Array{_A, 1} where _A, Tuple{Base.OneTo{Int64}}}, sparams=svec(), method=throw_checksize_error(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000046d9, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{AbstractArray{Float64, 1}, Float64}}, UInt64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d530a80)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{AbstractArray{Float64, 1}, Float64}}, UInt64}, sparams=svec(), method=(::Type{MethodError})(Any, Any, UInt64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000009c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IOContext{IO_t} where IO_t<:IO}, Base.GenericIOBuffer{Memory{UInt8}}, Pair{Symbol, _A} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422737279c0)[Core.MethodMatch(spec_types=Tuple{Type{Base.IOContext{IO_t} where IO_t<:IO}, Base.GenericIOBuffer{Memory{UInt8}}, Pair{Symbol, _A} where _A}, sparams=svec(), method=(::Type{Base.IOContext{IO_t} where IO_t<:IO})(IO, Pair{A, B} where B where A), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004148, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type, Real}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Any, 1}}, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Int64, 1}}, Vararg{Pair{Symbol, _A} where _A, 4}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e3747a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Any, 1}}, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Int64, 1}}, Vararg{Pair{Symbol, _A} where _A, 4}}}, sparams=svec(), method=iterate(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000067a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Generator{I, F} where F where I}, typeof(Base.identity), Base.SubArray{Any, 1, P, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, false} where P<:(Array{T, 1} where T<:Real)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226f6ab940)[Core.MethodMatch(spec_types=Tuple{Type{Base.Generator{I, F} where F where I}, typeof(Base.identity), Base.SubArray{Any, 1, P, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, false} where P<:(Array{T, 1} where T<:Real)}, sparams=svec(I<:(Base.SubArray{Any, 1, P, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, false} where P<:(Array{T, 1} where T<:Real)), typeof(Base.identity)), method=(::Type{Base.Generator{I, F} where F where I})(F, I) where {I, F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000420, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseArrays.nnz), SparseMatrixColorings.SparsityPatternCSC{Ti} where Ti<:Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a7a96b80)[Core.MethodMatch(spec_types=Tuple{typeof(SparseArrays.nnz), SparseMatrixColorings.SparsityPatternCSC{Ti} where Ti<:Integer}, sparams=svec(), method=nnz(SparseMatrixColorings.SparsityPatternCSC{Ti} where Ti<:Integer), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009689, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.methods), RipQP.var"#PreconditionerData##0#PreconditionerData##1"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422aa5002e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.methods), RipQP.var"#PreconditionerData##0#PreconditionerData##1"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Nothing}, sparams=svec(), method=methods(Any, Union{Nothing, Base.AbstractSet{Module}, Module, AbstractArray{Module, N} where N}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000057b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{ft} where ft<:(Base.Broadcast.Extruded{T, K, D} where D<:Tuple where K<:Tuple where T<:(Base.SubArray{T, 1, P, I, L} where L where I where P where T)), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Number)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226d436aa0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Number)}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, Base.Broadcast.Extruded{Union{}, Tuple{Bool}, Tuple{Int64}}} where Base.Broadcast.Extruded{Union{}, Tuple{Bool}, Tuple{Int64}}<:T<:(Base.Broadcast.Extruded{T, K, D} where D<:Tuple where K<:Tuple where T<:(Base.SubArray{T, 1, P, I, L} where L where I where P where T)), sparams=svec(Base.Broadcast.Extruded{Union{}, Tuple{Bool}, Tuple{Int64}}<:T<:(Base.Broadcast.Extruded{T, K, D} where D<:Tuple where K<:Tuple where T<:(Base.SubArray{T, 1, P, I, L} where L where I where P where T))), method=convert(Type{T}, T) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000034c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Type{Any}, Int64, Any, Any, Any, Any, Float64, Float64, Any, Float64, Float64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226df84c60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Type{Any}, Int64, Any, Any, Any, Any, Float64, Float64, Any, Float64, Float64}, sparams=svec(), method=getindex(Type{Any}, Any...), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010be, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LDLFactorizations.ldl_numeric_upper!), Int64, Array{Int64, 1}, Array{Int64, 1}, Array{T, 1} where T<:Real, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Tlow, 1} where Tlow<:Real, Array{Tlow, 1} where Tlow<:Real, Array{Tlow, 1} where Tlow<:Real, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}, Real, Real, Real, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226dfaf660)[Core.MethodMatch(spec_types=Tuple{typeof(LDLFactorizations.ldl_numeric_upper!), Int64, Array{Int64, 1}, Array{Int64, 1}, Array{T, 1} where T<:Real, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Tlow, 1} where Tlow<:Real, Array{Tlow, 1} where Tlow<:Real, Array{Tlow, 1} where Tlow<:Real, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}, Real, Real, Real, Int64}, sparams=svec(T<:(Array{Tlow, 1} where Tlow<:Real)), method=ldl_numeric_upper!(Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, T, Any, Any, Any, Any, Any, Any, Any, Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009767, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{LinearOperators.var"##_#2", Type, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where T, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##10#PreconditionerData##11"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Nothing, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226cae4420)[Core.MethodMatch(spec_types=Tuple{LinearOperators.var"##_#2", Type, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where T, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##10#PreconditionerData##11"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Nothing, Nothing}, sparams=svec(T, Int64), method=var"#_#2"(Type, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, I, I, Bool, Bool, Any, Any, Any) where {T, I<:Integer}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.merge!), Base.Dict{Symbol, _A} where _A, Base.Dict{Symbol, _A} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a6f6b9e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.merge!), Base.Dict{Symbol, _A} where _A, Base.Dict{Symbol, _A} where _A}, sparams=svec(), method=merge!(Base.AbstractDict{K, V} where V where K, (Base.AbstractDict{K, V} where V where K)...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000174b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.tail), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Ti, 1} where Ti<:Integer), Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742272c77a40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.tail), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Ti, 1} where Ti<:Integer), Int64}}, sparams=svec(), method=tail(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000035d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, Any, Tuple{Base.RefValue{typeof(Base.:(<))}, AbstractArray{Float64, 1}, AbstractArray{Float64, 1}}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742283cdd6c0)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, Any, Tuple{Base.RefValue{typeof(Base.:(<))}, AbstractArray{Float64, 1}, AbstractArray{Float64, 1}}, Nothing}, sparams=svec(F), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:(Array{_A, 1} where _A), Array{_A, 1} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74228836b9a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Array{_A, 1} where _A}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:(Array{_A, 1} where _A), Array{_A, 1} where _A}, sparams=svec(var"#s175"<:(Array{_A, 1} where _A)), method=convert(Type{T}, AbstractArray{T, N} where N where T) where {T<:(Array{T, N} where N where T)}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010dd, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LinearAlgebra.issuccess), SparseArrays.CHOLMOD.Factor{Tv, Int64} where Tv<:Union{Float32, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228c05e0e0)[Core.MethodMatch(spec_types=Tuple{typeof(LinearAlgebra.issuccess), SparseArrays.CHOLMOD.Factor{Tv, Int64} where Tv<:Union{Float32, Float64}}, sparams=svec(), method=issuccess(SparseArrays.CHOLMOD.Factor{Tv, Ti} where Ti<:Union{Int32, Int64} where Tv<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009675, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), RipQP.PreallocatedFloatData{Float64, S, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{Float64, S} where Dda<:RipQP.DescentDirectionAllocs{Float64, S} where Res<:RipQP.AbstractResiduals{Float64, S} where S<:AbstractArray{Float64, 1}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742289ab0740)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), RipQP.PreallocatedFloatData{Float64, S, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{Float64, S} where Dda<:RipQP.DescentDirectionAllocs{Float64, S} where Res<:RipQP.AbstractResiduals{Float64, S} where S<:AbstractArray{Float64, 1}, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(<=)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228aed3b80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(<=)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Int64}, sparams=svec(), method=checkbounds(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Integer), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004886, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74228f073420)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, sparams=svec(), method=combine_styles(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), Any}, sparams=svec(), method=combine_styles(Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004831, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{QuadraticModels.QuadraticModel{T, S, M1, M2} where M2 where M1 where S where T}, NLPModels.NLPModelMeta{T, S} where S where T, NLPModels.Counters, QuadraticModels.QPData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a93fb7c0)[Core.MethodMatch(spec_types=Tuple{Type{QuadraticModels.QuadraticModel{T, S, M1, M2} where M2 where M1 where S where T}, NLPModels.NLPModelMeta{T, S}, NLPModels.Counters, QuadraticModels.QPData{T, S, M1, M2}} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S where T, sparams=svec(T, S, M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}, M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}), method=(::Type{QuadraticModels.QuadraticModel{T, S, M1, M2} where M2 where M1 where S where T})(NLPModels.NLPModelMeta{T, S}, NLPModels.Counters, QuadraticModels.QPData{T, S, M1, M2}) where {T, S, M1, M2}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009745, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_rule), Type{Tuple{String, Function}}, Type{Tuple{String, typeof(JSOSolvers.tron)}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228f116560)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_rule), Type{Tuple{String, Function}}, Type{Tuple{String, typeof(JSOSolvers.tron)}}}, 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{Base.MappingRF{F, T} where T where F}, typeof(LinearAlgebra.norm), Base.BottomRF{typeof(Base.max)}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228c5b9200)[Core.MethodMatch(spec_types=Tuple{Type{Base.MappingRF{F, T} where T where F}, typeof(LinearAlgebra.norm), Base.BottomRF{typeof(Base.max)}}, sparams=svec(typeof(LinearAlgebra.norm), Base.BottomRF{typeof(Base.max)}), method=(::Type{Base.MappingRF{F, T} where T where F})(F, T) where {F, T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000031e9, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.Broadcast.Broadcasted{var"#s179", Nothing, typeof(Base.sqrt), var"#s179"} where var"#s179"<:Tuple{AbstractArray{Float64, 1}} where var"#s179"<:Base.Broadcast.BroadcastStyle}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228bd21720)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.Broadcast.Broadcasted{var"#s179", Nothing, typeof(Base.sqrt), var"#s179"} where var"#s179"<:Tuple{AbstractArray{Float64, 1}} where var"#s179"<:Base.Broadcast.BroadcastStyle}}}, sparams=svec(), method=(::Type{MethodError})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000009d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:var"join(keys(STATUSES), \", \")",), Tuple{String}}, typeof(Base.CoreLogging.handle_message_nothrow), Base.CoreLogging.AbstractLogger, Base.CoreLogging.LogLevel, String, Module, Symbol, Symbol, String, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422aa11e760)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:var"join(keys(STATUSES), \", \")",), Tuple{String}}, typeof(Base.CoreLogging.handle_message_nothrow), Base.CoreLogging.AbstractLogger, Base.CoreLogging.LogLevel, String, Module, Symbol, Symbol, String, Int64}, sparams=svec(), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(Base.CoreLogging.handle_message_nothrow), Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004f81, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.error_if_canonical_setindex), Base.IndexLinear, Array{Float64, 1}, Any, Base.IteratorsMD.CartesianIndex{0}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228c569f80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.error_if_canonical_setindex), Base.IndexLinear, Array{Float64, 1}, Any, Base.IteratorsMD.CartesianIndex{0}}, sparams=svec(), method=error_if_canonical_setindex(Base.IndexStyle, AbstractArray{T, N} where N where T, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012fe, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LDLFactorizations.ldl_ltsolve!), Int64, Any, Array{Int64, 1}, Array{Int64, 1}, Array{Tf, 1} where Tf<:Number}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226e1897e0)[ Core.MethodMatch(spec_types=Tuple{typeof(LDLFactorizations.ldl_ltsolve!), Int64, AbstractArray{T, 1} where T, Array{Int64, 1}, Array{Int64, 1}, Array{Tf, 1} where Tf<:Number}, sparams=svec(), method=ldl_ltsolve!(Any, AbstractArray{T, 1} where T, Any, Any, Any), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(LDLFactorizations.ldl_ltsolve!), Int64, AbstractArray{T, 2} where T, Array{Int64, 1}, Array{Int64, 1}, Array{Tf, 1} where Tf<:Number}, sparams=svec(), method=ldl_ltsolve!(Any, AbstractArray{T, 2} where T, Any, Any, Any), fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009767, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Array{T, 1} where T<:Real, Base.UnitRange{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a816fae0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Array{T, 1} where T<:Real, Base.UnitRange{Int64}}, sparams=svec(), method=checkbounds(AbstractArray{T, N} where N where T, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000127b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.update_preconditioner!), RipQP.PreconditionerData{T, S} where S where T<:Real, RipQP.PreallocatedDataK2Krylov{Float64, S, M, MT, Pr, Ksol} where Ksol<:(Krylov.KrylovWorkspace{T, FC, S} where S where FC where T) where Pr<:(RipQP.PreconditionerData{T, S} where S where T<:Real) where MT<:Union{Int64, RipQP.MatrixTools{Float64}} where M<:Union{AbstractArray{Float64, 2}, LinearOperators.LinearOperator{Float64, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where S, RipQP.IterData{Float64, S} where S, RipQP.Point{Float64, S} where S<:AbstractArray{T, 1} where T<:Real, RipQP.QM_IntData, RipQP.QM_FloatData_ref{Float64, S, M1, M2} where M2<:Union{AbstractArray{Float64, 2}, LinearOperators.AbstractLinearOperator{Float64}} where M1<:Union{AbstractArray{Float64, 2}, LinearOperators.AbstractLinearOperator{Float64}} where S, RipQP.Counters}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742283c4b880)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.update_preconditioner!), RipQP.LDLData{Float64, S, Tlow, Op, M, F} where F<:RipQP.FactorizationData{Tlow} where M<:Union{AbstractArray{Float64, 2}, LinearOperators.LinearOperator{Float64, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where Op<:Union{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T, RipQP.LRPrecond{Op1, Op2} where Op2 where Op1} where Tlow where S, RipQP.PreallocatedDataK2Krylov{Float64, S, M, MT, Pr, Ksol} where Ksol<:(Krylov.KrylovWorkspace{T, FC, S} where S where FC where T) where Pr<:(RipQP.PreconditionerData{T, S} where S where T<:Real) where MT<:Union{Int64, RipQP.MatrixTools{Float64}} where M<:Union{AbstractArray{Float64, 2}, LinearOperators.LinearOperator{Float64, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where S, RipQP.IterData{Float64, S} where S, RipQP.Point{Float64, S} where S<:AbstractArray{T, 1} where T<:Real, RipQP.QM_IntData, RipQP.QM_FloatData_ref{Float64, S, M1, M2} where M2<:Union{AbstractArray{Float64, 2}, LinearOperators.AbstractLinearOperator{Float64}} where M1<:Union{AbstractArray{Float64, 2}, LinearOperators.AbstractLinearOperator{Float64}} where S, RipQP.Counters}, sparams=svec(Float64), method=update_preconditioner!(RipQP.LDLData{T, S, Tlow, Op, M, F} where F<:RipQP.FactorizationData{Tlow} where M<:Union{AbstractArray{T, 2}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where Op<:Union{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T, RipQP.LRPrecond{Op1, Op2} where Op2 where Op1} where Tlow where S, RipQP.PreallocatedData{T, S} where S, RipQP.IterData{T, S} where S, RipQP.Point{T, S} where S, RipQP.QM_IntData, RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S, RipQP.Counters) where {T<:Real}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.axes), AbstractArray{T, 2} where T, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x74226e04d360)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.axes), SparseMatrixColorings.SparsityPatternCSC{Ti} where Ti<:Integer, Int64}, sparams=svec(), method=axes(SparseMatrixColorings.SparsityPatternCSC{Ti} where Ti<:Integer, Integer), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.axes), SparseArrays.ReadOnly{T, 2, V} where V<:AbstractArray{T, 2} where T, Int64}, sparams=svec(), method=axes(SparseArrays.ReadOnly{T, N, V} where V<:AbstractArray{T, N} where N where T, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.axes), AbstractArray{T, 2} where T, Int64}, sparams=svec(T, 2), method=axes(AbstractArray{T, N}, Any) where {T, N}, fully_covers=true), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009689, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{NLPModels.var"##_#43", Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Int64, Int64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Int64, Int64, Int64, Array{Int64, 1}, Bool, Bool, String, Type{NLPModels.NLPModelMeta{Float64, Array{Float64, 1}}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422863a6080)[Core.MethodMatch(spec_types=Tuple{NLPModels.var"##_#43", Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Int64, Int64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Int64, Int64, Int64, Array{Int64, 1}, Bool, Bool, String, Type{NLPModels.NLPModelMeta{Float64, Array{Float64, 1}}}, Int64}, sparams=svec(Float64, Array{Float64, 1}), method=var"#_#43"(S, S, S, Any, Any, Any, Any, S, S, S, Any, Any, Any, Any, Any, Any, Any, Any, Any, Type{NLPModels.NLPModelMeta{T, S}}, Int64) where {T, S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096b0, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{Base.SubArray{Any, 1, P, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, false} where P<:(Array{T, 1} where T<:Real), typeof(Base.identity)}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226f6f9720)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{Base.SubArray{Any, 1, P, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, false} where P<:(Array{T, 1} where T<:Real), typeof(Base.identity)}, Int64, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000689, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real} where var"#s175"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226cba8400)[Core.MethodMatch(spec_types=Tuple{Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real} where var"#s175"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Int64}, sparams=svec(var"#s175"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}), method=(::Base.var"#cvt1#convert##0"{T, x})(Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000376, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.objectid), LinearAlgebra.Diagonal{T, V} where V<:Array{T, 1} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228eb77080)[Core.MethodMatch(spec_types=Tuple{typeof(Base.objectid), LinearAlgebra.Diagonal{T, V} where V<:Array{T, 1} where T<:Real}, sparams=svec(), method=objectid(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000507, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Int64, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}}, UInt64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273bc2720)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Int64, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}}, UInt64}, sparams=svec(), method=(::Type{MethodError})(Any, Any, UInt64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000009c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Array{Tv, 1} where Tv<:Union{Float16, Float32}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226c1d2240)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Array{Tv, 1} where Tv<:Union{Float16, Float32}, Int64}, sparams=svec(), method=getindex(Array{T, N} where N where T, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000399, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.IteratorsMD.__inc), Any, Tuple{Vararg{Base.OrdinalRange{Int64, Int64}, N}} where N}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7422893bdf60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.IteratorsMD.__inc), Tuple{}, Tuple{}}, sparams=svec(), method=__inc(Tuple{}, Tuple{}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.IteratorsMD.__inc), Tuple{Int64, Int64, Vararg{Int64}}, Tuple{Base.OrdinalRange{Int64, Int64}, Base.OrdinalRange{Int64, Int64}, Vararg{Base.OrdinalRange{Int64, Int64}}}}, sparams=svec(), method=__inc(Tuple{Int64, Int64, Vararg{Int64}}, Tuple{Base.OrdinalRange{Int64, Int64}, Base.OrdinalRange{Int64, Int64}, Vararg{Base.OrdinalRange{Int64, Int64}}}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.IteratorsMD.__inc), Tuple{Int64}, Tuple{Base.OrdinalRange{Int64, Int64}}}, sparams=svec(), method=__inc(Tuple{Int64}, Tuple{Base.OrdinalRange{Int64, Int64}}), fully_covers=false), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004604, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.has_offset_axes), Array{ForwardDiff.Dual{Nothing, Float64, N}, 1} where N}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742270a021a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.has_offset_axes), Array{ForwardDiff.Dual{Nothing, Float64, N}, 1} where N}, sparams=svec(), method=has_offset_axes(Array{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001232, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{Union{QuadraticModels.AbstractQuadraticModel{Float64, S} where S, QuadraticModels.QuadraticModel{_A, _B, _C, _D} where _D where _C where _B where _A}, SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T, RipQP.IntDataInit{I} where I<:Integer}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228ca95320)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{Union{QuadraticModels.AbstractQuadraticModel{Float64, S} where S, QuadraticModels.QuadraticModel{_A, _B, _C, _D} where _D where _C where _B where _A}, SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T, RipQP.IntDataInit{I} where I<:Integer}, Int64, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000689, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), RipQP.InputConfig{I} where I<:Integer, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273834a20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), RipQP.InputConfig{I} where I<:Integer, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.rdims_trailing), Vararg{StaticArrays.SOneTo{n} where n}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7422852d7ce0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.rdims_trailing), StaticArrays.SOneTo{n} where n}, sparams=svec(), method=rdims_trailing(Any), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.rdims_trailing), StaticArrays.SOneTo{n} where n, Vararg{StaticArrays.SOneTo{n} where n}}, sparams=svec(), method=rdims_trailing(Any, Any...), fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000330a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.DimensionMismatch}, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a920be20)[Core.MethodMatch(spec_types=Tuple{Type{Base.DimensionMismatch}, String}, sparams=svec(), method=(::Type{Base.DimensionMismatch})(AbstractString), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001078, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.fill!), Any, LinearOperators.LinearOperator{_A, Int64, QuadraticModels.var"#opPermutedMinusOnes##0#opPermutedMinusOnes##1"{Array{Int64, 1}}, QuadraticModels.var"#opPermutedMinusOnes##2#opPermutedMinusOnes##3"{Array{Int64, 1}}, Nothing, T} where T where _A}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{Type{FillArrays.Zeros{T, N, Axes} where Axes where N} where T, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742272ec1820)[Core.MethodMatch(spec_types=Tuple{Type{FillArrays.Zeros{T, N, Axes} where Axes where N} where T, Tuple{Base.OneTo{Int64}}}, sparams=svec(T, 1, Tuple{Base.OneTo{Int64}}), method=(::Type{FillArrays.Zeros{T, N, Axes} where Axes where N})(SZ) where {T, N, SZ<:Tuple{Vararg{Any, N}}}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009681, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{RipQP.RipQPDoubleParameters{T, SP1, SP2, SM1, SM2} where SM2<:RipQP.SolveMethod where SM1<:RipQP.SolveMethod where SP2<:RipQP.SolverParams{T} where SP1<:(RipQP.SolverParams{T} where T) where T<:Real}, RipQP.K2LDLParams{_A, RipQP.LDLFact} where _A, Any, RipQP.PC, RipQP.PC}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228f44b040)[Core.MethodMatch(spec_types=Tuple{Type{RipQP.RipQPDoubleParameters{T, SP1, SP2, SM1, SM2} where SM2<:RipQP.SolveMethod where SM1<:RipQP.SolveMethod where SP2 where SP1<:(RipQP.SolverParams{T} where T) where T}, SP1, SP2, RipQP.PC, RipQP.PC} where SP2<:RipQP.SolverParams{T} where SP1<:(RipQP.K2LDLParams{_A, RipQP.LDLFact} where _A) where T<:Real, sparams=svec(T<:Real, SP1<:SP1<:(RipQP.K2LDLParams{_A, RipQP.LDLFact} where _A), SP2<:SP2<:RipQP.SolverParams{T<:Real}, RipQP.PC, RipQP.PC), method=(::Type{RipQP.RipQPDoubleParameters{T, SP1, SP2, SM1, SM2} where SM2 where SM1 where SP2 where SP1 where T})(SP1, SP2, SM1, SM2) where {T<:Real, SP1<:(RipQP.SolverParams{T} where T), SP2<:RipQP.SolverParams{T}, SM1<:RipQP.SolveMethod, SM2<:RipQP.SolveMethod}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.string), String, Type{T} where T<:Real, String, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74227379e800)[Core.MethodMatch(spec_types=Tuple{typeof(Base.string), String, Type{T} where T<:Real, String, String}, sparams=svec(), method=string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003db1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)} where var"#s179"<:Tuple, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x74226f3973a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)} where var"#s179"<:Tuple, LinearAlgebra.BandIndex}, sparams=svec(), method=checkbounds(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, LinearAlgebra.BandIndex), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)} where var"#s179"<:Tuple, Integer}, sparams=svec(), method=checkbounds(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Integer), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)} where var"#s179"<:Tuple, Base.IteratorsMD.CartesianIndex{N} where N}, sparams=svec(), method=checkbounds(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Base.IteratorsMD.CartesianIndex{N} where N), fully_covers=false), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000007ac1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.allocate_extra_workspace1), Any, RipQP.InputTol{T0, Int64} where T0<:Real, RipQP.InputConfig{I} where I<:Integer, RipQP.QM_FloatData{T, S, M1, M2} where M2 where M1 where S where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226bce0480)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.allocate_extra_workspace1), typeof(DataType), RipQP.InputTol{T0, Int64} where T0<:Real, RipQP.InputConfig{I} where I<:Integer, RipQP.QM_FloatData{T, S, M1, M2} where M2 where M1 where S where T<:Real}, sparams=svec(), method=allocate_extra_workspace1(typeof(DataType), RipQP.InputTol{T, I} where I<:Integer where T<:Real, RipQP.InputConfig{I} where I<:Integer, RipQP.QM_FloatData{T, S, M1, M2} where M2 where M1 where S where T<:Real), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{RipQP.QM_FloatData_ref{T, _A, M1, M2} where M2<:(Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T<:Real) where M1<:(Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T<:Real) where _A where T<:Real, RipQP.Point{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T<:Real where T<:Real}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422742aaf20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{RipQP.QM_FloatData_ref{T, _A, M1, M2} where M2<:(Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T<:Real) where M1<:(Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T<:Real) where _A where T<:Real, RipQP.Point{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T<:Real where T<:Real}, Int64, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000689, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:shift, :check), Tuple{Float64, Bool}}, typeof(LinearAlgebra.ldlt!), SparseArrays.CHOLMOD.Factor{Tnew, Int64} where Tnew<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}, SparseArrays.CHOLMOD.Sparse{Tv, Int64} where Tv<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228c6052c0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:shift, :check), Tuple{Float64, Bool}}, typeof(LinearAlgebra.ldlt!), SparseArrays.CHOLMOD.Factor{Tv, Int64}, SparseArrays.CHOLMOD.Sparse{Tv, Int64}} where Tv<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}, sparams=svec(Tv<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(LinearAlgebra.ldlt!), SparseArrays.CHOLMOD.Factor{Tv, Ti} where Ti<:Union{Int32, Int64}, SparseArrays.CHOLMOD.Sparse{Tv, Ti} where Ti<:Union{Int32, Int64}) where {Tv}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009675, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.increment!), ADNLPModels.ADNLPModel{T, V, Si} where Si where V<:AbstractArray{T, 1} where T, Base.Val{:neval_obj}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a9429560)[Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.increment!), ADNLPModels.ADNLPModel{T, V, Si} where Si where V<:AbstractArray{T, 1} where T, Base.Val{:neval_obj}}, sparams=svec(), method=increment!(NLPModels.AbstractNLPModel{T, S} where S where T, Base.Val{:neval_obj}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096b0, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Any, Base.RefValue{T} where T, AbstractArray{Float64, 1}, AbstractArray{Float64, 1}} where var"#s175"<:Tuple{Any, Base.RefValue{T} where T, AbstractArray{Float64, 1}, AbstractArray{Float64, 1}}, Base.Val{4}}, limit=5), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422837cb700)[Core.MethodMatch(spec_types=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Any, Base.RefValue{T} where T, AbstractArray{Float64, 1}, AbstractArray{Float64, 1}} where var"#s175"<:Tuple{Any, Base.RefValue{T} where T, AbstractArray{Float64, 1}, AbstractArray{Float64, 1}}, Base.Val{4}}, sparams=svec(F<:(Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Any, Base.RefValue{T} where T, AbstractArray{Float64, 1}, AbstractArray{Float64, 1}} where var"#s175"<:Tuple{Any, Base.RefValue{T} where T, AbstractArray{Float64, 1}, AbstractArray{Float64, 1}}), 4), method=ntuple(F, Base.Val{N}) where {F, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000017e3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{Integer, Int64}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742287bb40e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{Integer, Int64}, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000688, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Memory{typeof(DataType)}}, UndefInitializer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742289a1ee80)[Core.MethodMatch(spec_types=Tuple{Type{Memory{typeof(DataType)}}, UndefInitializer, Int64}, sparams=svec(typeof(DataType), 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(Base.get), LinearAlgebra.Diagonal{T, Union{}} where T<:Real, Tuple{Int64, Int64}, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228f360920)[Core.MethodMatch(spec_types=Tuple{typeof(Base.get), LinearAlgebra.Diagonal{T, Union{}} where T<:Real, Tuple{Int64, Int64}, Any}, sparams=svec(), method=get(AbstractArray{T, N} where N where T, Tuple{Vararg{Int64, N}} where N, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001327, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eps), Type{Float32}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273ad6aa0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.eps), Type{Float32}}, sparams=svec(), method=eps(Type{Float32}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000ef8, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{RipQP.LRPrecond{Op1, Op2} where Op2 where Op1}, Union{LinearAlgebra.UniformScaling{Bool}, LinearOperators.LinearOperator{Float64, Int64, F, Nothing, Nothing, _A} where _A where F<:(RipQP.var"#PreconditionerData##0#PreconditionerData##1"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real), LinearOperators.LinearOperator{Float64, Int64, F, Nothing, Nothing, _A} where _A where F<:(RipQP.var"#PreconditionerData##4#PreconditionerData##5"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real)}, Union{LinearAlgebra.UniformScaling{Bool}, LinearOperators.LinearOperator{Float64, Int64, F, Nothing, Nothing, _A} where _A where F<:(RipQP.var"#PreconditionerData##2#PreconditionerData##3"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real), LinearOperators.LinearOperator{Float64, Int64, F, Nothing, Nothing, _A} where _A where F<:(RipQP.var"#PreconditionerData##6#PreconditionerData##7"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real)}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422aa12d180)[Core.MethodMatch(spec_types=Tuple{Type{RipQP.LRPrecond{Op1, Op2} where Op2 where Op1}, Union{LinearAlgebra.UniformScaling{Bool}, LinearOperators.LinearOperator{Float64, Int64, F, Nothing, Nothing, _A} where _A where F<:(RipQP.var"#PreconditionerData##0#PreconditionerData##1"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real), LinearOperators.LinearOperator{Float64, Int64, F, Nothing, Nothing, _A} where _A where F<:(RipQP.var"#PreconditionerData##4#PreconditionerData##5"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real)}, Union{LinearAlgebra.UniformScaling{Bool}, LinearOperators.LinearOperator{Float64, Int64, F, Nothing, Nothing, _A} where _A where F<:(RipQP.var"#PreconditionerData##2#PreconditionerData##3"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real), LinearOperators.LinearOperator{Float64, Int64, F, Nothing, Nothing, _A} where _A where F<:(RipQP.var"#PreconditionerData##6#PreconditionerData##7"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real)}}, sparams=svec(Op1<:Union{LinearAlgebra.UniformScaling{Bool}, LinearOperators.LinearOperator{Float64, Int64, F, Nothing, Nothing, _A} where _A where F<:(RipQP.var"#PreconditionerData##0#PreconditionerData##1"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real), LinearOperators.LinearOperator{Float64, Int64, F, Nothing, Nothing, _A} where _A where F<:(RipQP.var"#PreconditionerData##4#PreconditionerData##5"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real)}, Op2<:Union{LinearAlgebra.UniformScaling{Bool}, LinearOperators.LinearOperator{Float64, Int64, F, Nothing, Nothing, _A} where _A where F<:(RipQP.var"#PreconditionerData##2#PreconditionerData##3"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real), LinearOperators.LinearOperator{Float64, Int64, F, Nothing, Nothing, _A} where _A where F<:(RipQP.var"#PreconditionerData##6#PreconditionerData##7"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real)}), method=(::Type{RipQP.LRPrecond{Op1, Op2} where Op2 where Op1})(Op1, Op2) where {Op1, Op2}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._any_tuple), Base.var"#TupleOrBottom##0#TupleOrBottom##1", Bool, Type}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273182680)[Core.MethodMatch(spec_types=Tuple{typeof(Base._any_tuple), Base.var"#TupleOrBottom##0#TupleOrBottom##1", Bool, Type}, sparams=svec(), method=_any_tuple(Any, Any, Any, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001ad6, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseArrays.LibSuiteSparse.cholmod_solve), Int64, SparseArrays.CHOLMOD.Factor{Tv, Int32} where Tv<:Union{Float32, Float64}, SparseArrays.CHOLMOD.Dense{Tv} where Tv<:Union{Float32, Float64}, Ref{SparseArrays.LibSuiteSparse.cholmod_common_struct}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a70351e0)[Core.MethodMatch(spec_types=Tuple{typeof(SparseArrays.LibSuiteSparse.cholmod_solve), Int64, SparseArrays.CHOLMOD.Factor{Tv, Int32} where Tv<:Union{Float32, Float64}, SparseArrays.CHOLMOD.Dense{Tv} where Tv<:Union{Float32, Float64}, Ref{SparseArrays.LibSuiteSparse.cholmod_common_struct}}, sparams=svec(), method=cholmod_solve(Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009675, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._getindex), Base.IndexLinear, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226e932260)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._getindex), Base.IndexLinear, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Int64}, sparams=svec(), method=_getindex(Base.IndexStyle, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000487e, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ReverseDiff.valtype), Type{T} where T<:(ReverseDiff.TrackedReal{V, D, ReverseDiff.TrackedArray{V, D, 1, VA, DA}} where V<:Real where D<:Real where VA where DA)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a8185360)[Core.MethodMatch(spec_types=Tuple{typeof(ReverseDiff.valtype), Type{ReverseDiff.TrackedReal{V, D, ReverseDiff.TrackedArray{V, D, 1, VA, DA}}}} where DA where VA where D<:Real where V<:Real, sparams=svec(V<:Real, D<:Real, O<:(ReverseDiff.TrackedArray{V, D, 1, VA, DA} where V<:Real where D<:Real where VA where DA)), method=valtype(Type{ReverseDiff.TrackedReal{V, D, O}}) where {V, D, O}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._tuple_error), Type{var"#s175"} where var"#s175"<:Tuple{Array{R, 1} where R, Any}, Tuple{Array{R, 1} where R, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742271b80920)[Core.MethodMatch(spec_types=Tuple{typeof(Base._tuple_error), Type{var"#s175"} where var"#s175"<:Tuple{Array{R, 1} where R, Any}, Tuple{Array{R, 1} where R, Any}}, sparams=svec(), method=_tuple_error(Type, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000372, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), GenericMemoryRef{:not_atomic, T, Core.AddrSpace{Core}(0x00)} where T<:(QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2} where T where S where M1 where M2), Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226e5776c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), GenericMemoryRef{:not_atomic, T, Core.AddrSpace{Core}(0x00)} where T<:(QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2} where T where S where M1 where M2), Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.RefValue{typeof(Base.:(-))}, Any, Array{T, N} where N where T}}, UInt64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422862fdfe0)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.RefValue{typeof(Base.:(-))}, Any, Array{T, N} where N where T}}, UInt64}, sparams=svec(), method=(::Type{MethodError})(Any, Any, UInt64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000009c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.Dict{K, Any} where K, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422aa14e320)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.Dict{K, Any} where K, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{Bool, Tuple{Any}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273a97660)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{Bool, Tuple{Any}}, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000688, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Iterators._zip_iterate_some), Tuple{Any}, Tuple{Tuple{Any}}, Tuple{Any}, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7422883d2e60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators._zip_iterate_some), Tuple{Any}, Tuple{Tuple{Any}}, Tuple{Bool}, Bool}, sparams=svec(Bool), method=_zip_iterate_some(Any, Any, Tuple{T, Vararg{Any}}, T) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators._zip_iterate_some), Tuple{Any}, Tuple{Tuple{Any}}, Tuple{Any}, Bool}, sparams=svec(), method=_zip_iterate_some(Any, Any, Tuple{Any, Vararg{Any}}, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000018c7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.StepRangeLen{_A, Base.TwicePrecision{Float64}, S, _B}} where _B where S<:(Base.TwicePrecision{T} where T<:Union{Float16, Float32, Float64}) where _A, Base.TwicePrecision{Float64}, Base.TwicePrecision{T} where T<:Union{Float16, Float32, Float64}, Integer, Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228b236f00)[Core.MethodMatch(spec_types=Tuple{Type{Base.StepRangeLen{T, Base.TwicePrecision{Float64}, S, L}}, Base.TwicePrecision{Float64}, Base.TwicePrecision{T} where T<:Union{Float16, Float32, Float64}, Integer, Integer} where L where S<:(Base.TwicePrecision{T} where T<:Union{Float16, Float32, Float64}) where T, sparams=svec(T, R, S, L), method=(::Type{Base.StepRangeLen{T, R, S, L}})(R, S, Integer, Integer) where {T, R, S, L}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000008b1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcast_unalias), Base.SubArray{T, 1, P, I, L} where L where I where P where T, Array{T, 1} where T<:Number}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d50b580)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcast_unalias), Base.SubArray{T, 1, P, I, L} where L where I where P where T, Array{T, 1} where T<:Number}, sparams=svec(), method=broadcast_unalias(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048c7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.RefValue{typeof(Base.:(<=))}, Array{T, N} where N where T, Any}}, UInt64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228770fc80)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.RefValue{typeof(Base.:(<=))}, Array{T, N} where N where T, Any}}, UInt64}, sparams=svec(), method=(::Type{MethodError})(Any, Any, UInt64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000009c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.throw_boundserror), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226cc8aa20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.throw_boundserror), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Tuple{Int64}}, sparams=svec(), method=throw_boundserror(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000310, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Array{_A, 1}} where _A, Array{T, 1} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228dee6740)[Core.MethodMatch(spec_types=Tuple{Type{Array{_A, 1}} where _A, Array{T, 1} where T}, sparams=svec(_A, 1, T), method=(::Type{Array{T, N}})(AbstractArray{S, N}) where {T, N, S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010df, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_result), Type{Tuple{String, Function}}, Type{Tuple{String, Main.var"#tests##16#tests##17"{Main.var"#tests##18#tests##19"}}}, Type{Union{}}, Type{Union{}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d895f60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_result), Type{Tuple{String, Function}}, Type{Tuple{String, Main.var"#tests##16#tests##17"{Main.var"#tests##18#tests##19"}}}, Type{Union{}}, Type{Union{}}}, sparams=svec(Tuple{String, Function}, Tuple{String, Main.var"#tests##16#tests##17"{Main.var"#tests##18#tests##19"}}), method=promote_result(Type{T}, Type{S}, Type{Union{}}, Type{Union{}}) where {T, S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000603, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core._typeof_captured_variable), Tuple{Any, Base.RefValue{T} where T, Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422831d3f20)[Core.MethodMatch(spec_types=Tuple{typeof(Core._typeof_captured_variable), Tuple{Any, Base.RefValue{T} where T, Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}}}, sparams=svec(), method=_typeof_captured_variable(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000004a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, StaticArraysCore.StaticArrayStyle{2}, typeof(SparseMatricesCOO.replace_if_minusinf), Tuple{LinearAlgebra.Adjoint{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where Float64<:T<:Real, Int64}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742287bdaca0)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, StaticArraysCore.StaticArrayStyle{2}, typeof(SparseMatricesCOO.replace_if_minusinf), Tuple{LinearAlgebra.Adjoint{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where Float64<:T<:Real, Int64}, Nothing}, sparams=svec(typeof(SparseMatricesCOO.replace_if_minusinf)), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(FillArrays.broadcasted_fill), typeof(Base.min), FillArrays.AbstractFill{T, 1, Axes} where Axes where T<:Real, FillArrays.AbstractFill{T, 1, Axes} where Axes where T<:Real, Any, Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a99767a0)[Core.MethodMatch(spec_types=Tuple{typeof(FillArrays.broadcasted_fill), typeof(Base.min), FillArrays.AbstractFill{T, 1, Axes} where Axes where T<:Real, FillArrays.AbstractFill{T, 1, Axes} where Axes where T<:Real, Any, Tuple}, sparams=svec(), method=broadcasted_fill(Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009681, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eachindex), LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4711", 2} where var"#s4711"<:T) where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226f2c57a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4711", 2} where var"#s4711"<:T) where T}, sparams=svec(), method=eachindex(AbstractArray{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001253, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_typeof), Int64, Any, Any, Any, Any, Type{String}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a9cc76e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_typeof), Int64, Any, Any, Any, Any, Type{String}}, sparams=svec(), method=promote_typeof(Any, Any, Any, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000060f, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.cat_similar), Array{Ti, 1} where Ti<:Integer, Type, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228439c9c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.cat_similar), Array{Ti, 1} where Ti<:Integer, Type, Tuple{Int64}}, sparams=svec(T), method=cat_similar(Array{T, N} where N where T, Type{T}, Tuple) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001388, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:Base.Broadcast.Extruded{FillArrays.Fill{Float64, 1, Tuple{Base.OneTo{Int64}}}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{FillArrays.Fill{Float64, 1, Tuple{Base.OneTo{Int64}}}, Tuple{Bool}, Tuple{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x742274571320)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Base.Broadcast.Extruded{FillArrays.Fill{Float64, 1, Tuple{Base.OneTo{Int64}}}, Tuple{Bool}, Tuple{Int64}}}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Base.Broadcast.Extruded{FillArrays.Fill{Float64, 1, Tuple{Base.OneTo{Int64}}}, Tuple{Bool}, Tuple{Int64}}}, Base.Broadcast.Extruded{FillArrays.Fill{Float64, 1, Tuple{Base.OneTo{Int64}}}, Tuple{Bool}, Tuple{Int64}}}, sparams=svec(Base.Broadcast.Extruded{FillArrays.Fill{Float64, 1, Tuple{Base.OneTo{Int64}}}, Tuple{Bool}, Tuple{Int64}}), method=convert(Type{T}, T) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000034c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), StaticArraysCore.Size{S} where S, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d234600)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), StaticArraysCore.Size{S} where S, Int64}, sparams=svec(S), method=getindex(StaticArraysCore.Size{S}, Int64) where {S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000969d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.to_indices), Array{_A, 1} where _A, Tuple{Base.OneTo{Int64}}, Tuple{Base.UnitRange{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a7093ae0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.to_indices), Array{_A, 1} where _A, Tuple{Base.OneTo{Int64}}, Tuple{Base.UnitRange{Int64}}}, sparams=svec(), method=to_indices(Any, Any, Tuple{Any, Vararg}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000fdc, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Array{T, 1} where T<:Real, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228364a920)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Array{T, 1} where T<:Real, Int64}, sparams=svec(), method=getindex(Array{T, N} where N where T, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000399, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.mightalias), Array{Float64, 1}, Array{_A, 1} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x742289ab4220)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.mightalias), Array{Float64, 1}, Array{_A, 1} where _A}, sparams=svec(), method=mightalias(AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001312, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{LimitedLDLFactorizations.LimitedLDLFactorization{T, Ti, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Ti<:Integer where T<:Real}, Bool, Int64, Array{_A, 1} where _A, Array{_A, 1} where _A, Base.SubArray{_A, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{_A, 1} where _A) where _A, Array{T, 1} where T<:Real, Base.SubArray{Any, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{T, 1} where T<:Real), Int64, Array{T, 1} where T<:Real, Array{T, 1} where T<:Real, Array{Int64, 1}, Real, Real, Any, Int64, Array{Int64, 1}, Array{T, 1} where T<:Real, Array{T, 1} where T<:Real, Array{T, 1} where T<:Real, Array{_A, 1} where _A, Array{_A, 1} where _A, Array{Float64, 2}, Any, Any, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(0,), mem=Memory{Any}(0, 0x7422b4033d90)[]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000000, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), QuadraticModels.QuadraticModelPresolveData{T, S} where S where T, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422845e8940)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), QuadraticModels.QuadraticModelPresolveData{T, S} where S where T, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422700ada60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A}, Int64}, sparams=svec(), method=iterate(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000067b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.cconvert), Type{Ptr{SparseArrays.LibSuiteSparse.cholmod_dense_struct}}, SparseArrays.CHOLMOD.Dense{Tv} where Tv<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226f1994a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.cconvert), Type{Ptr{SparseArrays.LibSuiteSparse.cholmod_dense_struct}}, SparseArrays.CHOLMOD.Dense{Tv} where Tv<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}}, 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{Base.IndexStyle}, Type{Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), var"#s179"}} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)} where var"#s179"<:Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226f3b15e0)[ Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Type{Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), var"#s179"}} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)} where var"#s179"<:Tuple{Any}}, sparams=svec(), method=(::Type{Base.IndexStyle})(Type{var"#s677"} where var"#s677"<:(Base.Broadcast.Broadcasted{var"#s676", var"#s675", F, Args} where Args<:Tuple where F where var"#s675"<:Tuple{Any} where var"#s676")), fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Type{Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), var"#s179"}} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)} where var"#s179"<:Tuple}, sparams=svec(), method=(::Type{Base.IndexStyle})(Type{var"#s677"} where var"#s677"<:(Base.Broadcast.Broadcasted{var"#s676", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s676")), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047eb, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core._typeof_captured_variable), AbstractArray{T, 1} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d3a7c00)[Core.MethodMatch(spec_types=Tuple{typeof(Core._typeof_captured_variable), AbstractArray{T, 1} where T}, sparams=svec(), method=_typeof_captured_variable(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000004a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.grow_to!), Base.Dict{K, V} where V where K, Tuple{Pair{Symbol, Int64}, Vararg{Pair{A, B} where B where A}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a6d49e80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.grow_to!), Base.Dict{K, V} where V where K, Tuple{Pair{Symbol, Int64}, Vararg{Pair{A, B} where B where A}}, Int64}, sparams=svec(K, V), method=grow_to!(Base.AbstractDict{K, V}, Any, Any) where {K, V}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001784, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:(LinearOperators.var"#*##0#*##1"{LinearOperators.AdjointLinearOperator{T, S}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}, _A} where _A where S where Fct where Ft where F where I<:Integer where T where S where T), LinearOperators.var"#*##0#*##1"{LinearOperators.AdjointLinearOperator{T, S}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}, _A} where _A where S where Fct where Ft where F where I<:Integer where T where S where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226f1b6ba0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, LinearOperators.var"#*##0#*##1"{LinearOperators.AdjointLinearOperator{T, S}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}, _A} where _A where S where Fct where Ft where F where I<:Integer where T where S where T}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, LinearOperators.var"#*##0#*##1"{LinearOperators.AdjointLinearOperator{T, S}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}, _A} where _A where S where Fct where Ft where F where I<:Integer where T where S where T} where T<:(LinearOperators.var"#*##0#*##1"{LinearOperators.AdjointLinearOperator{T, S}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}, _A} where _A where S where Fct where Ft where F where I<:Integer where T where S where T), sparams=svec(T), method=convert(Type{T}, T) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000034c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{var"#s175"} where var"#s175"<:(Array{ForwardDiff.Dual{T, Float64, _A}, 1} where _A where T<:(ForwardDiff.Tag{_A, Float64} where _A)), Array{ForwardDiff.Dual{T, Float64, _A}, 1} where _A where T<:(ForwardDiff.Tag{_A, Float64} where _A)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226e9b9660)[ Core.MethodMatch(spec_types=Tuple{Type{Union{}}, Array{ForwardDiff.Dual{T, Float64, _A}, 1} where _A where T<:(ForwardDiff.Tag{_A, Float64} where _A)}, sparams=svec(), method=(::Type{Union{}})(Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{Array{ForwardDiff.Dual{T, Float64, _A}, 1}}, Array{ForwardDiff.Dual{T, Float64, _A}, 1}} where T<:(ForwardDiff.Tag{_A, Float64} where _A) where _A where T<:(ForwardDiff.Tag{_A, Float64} where _A) where _A, sparams=svec(T<:(ForwardDiff.Dual{T, Float64, _A} where T<:(ForwardDiff.Tag{_A, Float64} where _A) where _A), 1, S<:(ForwardDiff.Dual{T, Float64, _A} where T<:(ForwardDiff.Tag{_A, Float64} where _A) where _A)), method=(::Type{Array{T, N}})(AbstractArray{S, N}) where {T, N, S}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010df, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, typeof(RipQP.safe_boundary), Tuple{AbstractArray{Float64, 1}}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228416c6e0)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, typeof(RipQP.safe_boundary), Tuple{AbstractArray{Float64, 1}}, Nothing}, sparams=svec(typeof(RipQP.safe_boundary)), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Iterators.zip), Base.OneTo{Int64}, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273a4f400)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators.zip), Base.OneTo{Int64}, Any}, sparams=svec(), method=zip(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000018a5, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unwrap_composed), Base.ComposedFunction{Base.ComposedFunction{typeof(Base.identity), Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLPModel{T, S, Si}, Array{Int64, 1}, Int64}}}, Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}}} where Si where S where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742288a07ec0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unwrap_composed), Base.ComposedFunction{Base.ComposedFunction{typeof(Base.identity), Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLPModel{T, S, Si}, Array{Int64, 1}, Int64}}}, Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}}} where Si where S where T}, sparams=svec(), method=unwrap_composed(Base.ComposedFunction{O, I} where I where O), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c29, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(-)), Any, Float64}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{LinearOperators.var"##_#1", Type, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##0#PreconditionerData##1"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Nothing, Nothing, Int64, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742271205440)[Core.MethodMatch(spec_types=Tuple{LinearOperators.var"##_#1", Type, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##0#PreconditionerData##1"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Nothing, Nothing, Int64, Int64, Int64}, sparams=svec(T<:Real, Int64, F<:(RipQP.var"#PreconditionerData##0#PreconditionerData##1"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real), Nothing, Nothing), method=var"#_#1"(Type, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, I, I, Bool, Bool, F, Ft, Fct, I, I, I) where {T, I<:Integer, F, Ft, Fct}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, T}} where T where F<:(RipQP.var"#PreconditionerData##14#PreconditionerData##15"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Int64, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Tf<:Real) where Tlow<:Real) where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##14#PreconditionerData##15"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Int64, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Tf<:Real) where Tlow<:Real, Nothing, Nothing, Int64, Int64, Int64, Bool, Bool, Any, Any, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a79ec3a0)[Core.MethodMatch(spec_types=Tuple{Type{LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, T}} where T where F<:(RipQP.var"#PreconditionerData##14#PreconditionerData##15"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Int64, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Tf<:Real) where Tlow<:Real) where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##14#PreconditionerData##15"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Int64, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Tf<:Real) where Tlow<:Real, Nothing, Nothing, Int64, Int64, Int64, Bool, Bool, Any, Any, Bool}, sparams=svec(), method=(::Type{LinearOperators.LinearOperator{T, I<:Integer, F, Ft, Fct, S}})(Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Generator{I, F} where F where I}, Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##0#__cat_offset1!##1"{var"#s179", Tuple{Bool, Bool}, Tuple{Vararg{Int64, N}}, _A}} where _A where N where var"#s179"<:Tuple{Any, Any, Vararg{Int64}}, Base.UnitRange{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e601d40)[Core.MethodMatch(spec_types=Tuple{Type{Base.Generator{I, F} where F where I}, Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##0#__cat_offset1!##1"{var"#s179", Tuple{Bool, Bool}, Tuple{Vararg{Int64, N}}, _A}} where _A where N where var"#s179"<:Tuple{Any, Any, Vararg{Int64}}, Base.UnitRange{Int64}}, sparams=svec(Base.UnitRange{Int64}, F<:(Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##0#__cat_offset1!##1"{var"#s179", Tuple{Bool, Bool}, Tuple{Vararg{Int64, N}}, _A}} where _A where N where var"#s179"<:Tuple{Any, Any, Vararg{Int64}})), method=(::Type{Base.Generator{I, F} where F where I})(F, I) where {I, F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000420, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.TwicePrecision{Float64}}, Float64, Float64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228b2e2600)[Core.MethodMatch(spec_types=Tuple{Type{Base.TwicePrecision{Float64}}, Float64, Float64}, sparams=svec(), method=(::Type{Base.TwicePrecision{T}})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002ec5, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_result), Type, Type{Tuple{String, Main.var"#tests##4#tests##5"{Main.var"#tests##6#tests##7"}}}, Any, Type{Union{}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7422a7556da0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_result), Type{T}, Type{Tuple{String, Main.var"#tests##4#tests##5"{Main.var"#tests##6#tests##7"}}}, Type{Union{}}, Type{Union{}}} where T, sparams=svec(T, Tuple{String, Main.var"#tests##4#tests##5"{Main.var"#tests##6#tests##7"}}), method=promote_result(Type{T}, Type{S}, Type{Union{}}, Type{Union{}}) where {T, S}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_result), Type, Type{Tuple{String, Main.var"#tests##4#tests##5"{Main.var"#tests##6#tests##7"}}}, Type{T}, Type{Union{}}} where T, sparams=svec(T, Union{}), method=promote_result(Type, Type, Type{T}, Type{S}) where {T, S}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000603, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.push!), Array{T, 1} where T<:Real, Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226f2cfae0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.push!), Array{T, 1} where T<:Real, Real}, sparams=svec(T<:Real), method=push!(Array{T, 1}, Any) where {T}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000113a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.string), String, Type{A} where A<:(StaticArraysCore.StaticArray{Tuple{var"#s7", var"#s8"}, Float64, 2} where var"#s8" where var"#s7"), String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d4259a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.string), String, Type{A} where A<:(StaticArraysCore.StaticArray{Tuple{var"#s7", var"#s8"}, Float64, 2} where var"#s8" where var"#s7"), String}, sparams=svec(), method=string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003db1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{StaticArraysCore.Size{S} where S}, LinearAlgebra.Adjoint{T, var"#s179"} where var"#s179"<:(StaticArraysCore.StaticArray{Tuple{var"#s2"}, T, 1} where var"#s2") where Float64<:T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742282d77820)[Core.MethodMatch(spec_types=Tuple{Type{StaticArraysCore.Size{S} where S}, LinearAlgebra.Adjoint{T, var"#s179"} where var"#s179"<:(StaticArraysCore.StaticArray{Tuple{var"#s2"}, T, 1} where var"#s2") where Float64<:T<:Real}, sparams=svec(T<:(LinearAlgebra.Adjoint{T, var"#s179"} where var"#s179"<:(StaticArraysCore.StaticArray{Tuple{var"#s2"}, T, 1} where var"#s2") where Float64<:T<:Real)), method=(::Type{StaticArraysCore.Size{S} where S})(T) where {T<:(AbstractArray{T, N} where N where T)}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000968c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), QuadraticModels.PresolvedData{Float64, S} where S, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422865c1aa0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), QuadraticModels.PresolvedData{Float64, S} where S, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.merge_types), Tuple{Vararg{Symbol}}, Type{NamedTuple{(:lvar, :uvar, :ncon, :lcon, :ucon, :nnzj, :lin_nnzj, :nln_nnzj, :nnzh, :lin, :islp), var"#s179"}} where var"#s179"<:Tuple{Array{_A, 1} where _A, Array{_A, 1} where _A, Int64, Array{_A, 1} where _A, Array{_A, 1} where _A, Int64, Int64, Int64, Int64, Base.UnitRange{Int64}, Bool}, Type{NamedTuple{names, T}} where T<:Tuple{Vararg{Any, N}} where names where N}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228c4428c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.merge_types), Tuple{Vararg{Symbol}}, Type{NamedTuple{(:lvar, :uvar, :ncon, :lcon, :ucon, :nnzj, :lin_nnzj, :nln_nnzj, :nnzh, :lin, :islp), var"#s179"}} where var"#s179"<:Tuple{Array{_A, 1} where _A, Array{_A, 1} where _A, Int64, Array{_A, 1} where _A, Array{_A, 1} where _A, Int64, Int64, Int64, Int64, Base.UnitRange{Int64}, Bool}, Type{NamedTuple{names, T}} where T<:Tuple{Vararg{Any, N}} where names where N}, sparams=svec(), method=merge_types(Tuple{Vararg{Symbol}}, Type{var"#s179"} where var"#s179"<:(NamedTuple{names, T} where T<:Tuple where names), Type{var"#s178"} where var"#s178"<:(NamedTuple{names, T} where T<:Tuple where names)), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001a97, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}}, Int64, Int64, Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742284a832a0)[Core.MethodMatch(spec_types=Tuple{Type{SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}}, Int64, Int64, Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 1}}, sparams=svec(Float64, Int64), method=(::Type{SparseMatricesCOO.SparseMatrixCOO{Tv, Ti}})(Integer, Integer, Array{Ti, 1}, Array{Ti, 1}, Array{Tv, 1}) where {Tv, Ti<:Integer}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009744, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), AbstractArray{T, 1} where Float64<:T<:Real, Base.Broadcast.Broadcasted{var"#s179", Nothing, typeof(Base.sqrt), var"#s179"} where var"#s179"<:Tuple{AbstractArray{T, 1} where Float64<:T<:Real} where var"#s179"<:Base.Broadcast.BroadcastStyle}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x742283e01ea0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), AbstractArray{T, 1} where Float64<:T<:Real, Base.Broadcast.Broadcasted{var"#s179", Nothing, typeof(Base.sqrt), var"#s179"} where var"#s179"<:Tuple{AbstractArray{T, 1} where Float64<:T<:Real} where var"#s179"<:Base.Broadcast.BroadcastStyle}, sparams=svec(), method=materialize!(Any, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048be, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.fill!), Base.SubArray{_A, _B, P, I, true} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A, Int64}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.:(<)), Tuple{Base.UnitRange{Int64}, Int64}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d4d0460)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.:(<)), Tuple{Base.UnitRange{Int64}, Int64}, Tuple{Base.OneTo{Int64}}}, sparams=svec(typeof(Base.:(<))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), AbstractArray{var"#s4711", 2} where var"#s4711", Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.StepRangeLen{_A, _B, Int64, L} where L<:Integer} where _B where _A, Any, Int64, Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422878782c0)[Core.MethodMatch(spec_types=Tuple{Type{Base.StepRangeLen{T, R, Int64, L} where L<:Integer}, Any, Int64, Integer} where R where T, sparams=svec(T, R, S), method=(::Type{Base.StepRangeLen{T, R, S, L} where L<:Integer})(R, S, Integer) where {T, R, S}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000008b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.ismutable), SparseArrays.CHOLMOD.Sparse{Tv, Int32} where Tv<:Union{Float32, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228bbebfa0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.ismutable), SparseArrays.CHOLMOD.Sparse{Tv, Int32} where Tv<:Union{Float32, Float64}}, sparams=svec(), method=ismutable(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000004f9, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ReverseDiff._convert), Type{D} where D<:Real, Real}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.ComposedFunction{O, I} where I where O}, typeof(Base.identity), Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, Base.var"#_bool##0#_bool##1"{typeof(SparseArrays._isnotzero)}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422845803c0)[Core.MethodMatch(spec_types=Tuple{Type{Base.ComposedFunction{O, I} where I where O}, typeof(Base.identity), Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, Base.var"#_bool##0#_bool##1"{typeof(SparseArrays._isnotzero)}}}, sparams=svec(), method=(::Type{Base.ComposedFunction{O, I} where I where O})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c23, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Fix{1, F, T} where T where F}, typeof(Base.to_index), Array{T, 1} where T<:Number}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d21a380)[Core.MethodMatch(spec_types=Tuple{Type{Base.Fix{1, F, T} where T where F}, typeof(Base.to_index), Array{T, 1} where T<:Number}, sparams=svec(1, typeof(Base.to_index)), method=(::Type{Base.Fix{N, F, T} where T where F})(F, Any) where {N, F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c46, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._compute_eltype), Type{var"#s179"} where var"#s179"<:Tuple{Pair{Symbol, Nothing}, Pair{Symbol, Array{QuadraticModels.PresolveOperation{T, _A}, 1}} where _A where T<:Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d7e18e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._compute_eltype), Type{var"#s179"} where var"#s179"<:Tuple{Pair{Symbol, Nothing}, Pair{Symbol, Array{QuadraticModels.PresolveOperation{T, _A}, 1}} where _A where T<:Real}}, sparams=svec(), method=_compute_eltype(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006ab, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.solver!), Any, RipQP.PreallocatedDataK2LDL{T, _A, F, _B} where _B<:AbstractArray{T, 2} where F<:(RipQP.LDLFactorizationData{T} where T) where _A where T<:Real, RipQP.DescentDirectionAllocs{T, S} where S where T<:Real, RipQP.Point{T, S} where S where T<:Real, RipQP.IterData{T, S} where S where T<:Real, RipQP.QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S where T<:Real, RipQP.QM_IntData, RipQP.AbstractResiduals{T, S} where S where T<:Real, RipQP.Counters, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422745307a0)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.solver!), AbstractArray{T, 1}, RipQP.PreallocatedDataK2LDL{T, _A, F, _B} where _B<:AbstractArray{T, 2} where F<:(RipQP.LDLFactorizationData{T} where T) where _A, RipQP.DescentDirectionAllocs{T, S} where S, RipQP.Point{T, S} where S, RipQP.IterData{T, S} where S, RipQP.QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S, RipQP.QM_IntData, RipQP.AbstractResiduals{T, S} where S, RipQP.Counters, Symbol} where T<:Real, sparams=svec(T<:Real), method=solver!(AbstractArray{T, 1}, RipQP.PreallocatedDataK2LDL{T, S, F, M} where M<:AbstractArray{T, 2} where F where S, RipQP.DescentDirectionAllocs{T, S} where S, RipQP.Point{T, S} where S, RipQP.IterData{T, S} where S, RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S, RipQP.QM_IntData, RipQP.AbstractResiduals{T, S} where S, RipQP.Counters, Symbol) where {T<:Real}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(QuadraticModels.restore_y!), Array{Bool, 1}, AbstractArray{T, 1} where T<:Real, AbstractArray{T, 1} where T<:Real, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228b1cee20)[Core.MethodMatch(spec_types=Tuple{typeof(QuadraticModels.restore_y!), Array{Bool, 1}, Array{T, 1}, Array{T, 1}, Int64} where T<:Real, sparams=svec(T<:Real), method=restore_y!(Array{Bool, 1}, Array{T, 1}, Array{T, 1}, Any) where {T}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009745, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{ft} where ft<:Real, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.methods), RipQP.var"#PreconditionerData##6#PreconditionerData##7"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e4fad40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.methods), RipQP.var"#PreconditionerData##6#PreconditionerData##7"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}, Nothing}, sparams=svec(), method=methods(Any, Union{Nothing, Base.AbstractSet{Module}, Module, AbstractArray{Module, N} where N}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000057b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LinearOperators.get_nargs), RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Int64, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Tf<:Real) where Tlow<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a7092840)[Core.MethodMatch(spec_types=Tuple{typeof(LinearOperators.get_nargs), RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Int64, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Tf<:Real) where Tlow<:Real}, sparams=svec(), method=get_nargs(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.methods), RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Int64, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Tf<:Real) where Tlow<:Real, Type{Tuple}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a707e2e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.methods), RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Int64, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Tf<:Real) where Tlow<:Real, Type{Tuple}, Nothing}, sparams=svec(), method=methods(Any, Any, Union{Nothing, Base.AbstractSet{Module}, Tuple{Module}, AbstractArray{Module, N} where N}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000576, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), SparseArrays.SparseMatrixCSC{Float64, Ti} where Ti<:Integer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742283e5c420)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), SparseArrays.SparseMatrixCSC{Float64, Ti} where Ti<:Integer, Int64}, sparams=svec(Float64, 2), method=size(AbstractArray{T, N}, Any) where {T, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001228, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.map), Base.var"#view##0#view##1"{Array{_A, 1}} where _A, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226dbdcc60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.map), Base.var"#view##0#view##1"{Array{_A, 1}} where _A, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}}, sparams=svec(), method=map(Any, Tuple{Any}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006bc, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.rdims), Tuple{StaticArrays.SOneTo{1}}, Tuple{StaticArrays.SOneTo{n} where n, Vararg{StaticArrays.SOneTo{n} where n}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742286583980)[Core.MethodMatch(spec_types=Tuple{typeof(Base.rdims), Tuple{StaticArrays.SOneTo{1}}, Tuple{StaticArrays.SOneTo{n} where n, Vararg{StaticArrays.SOneTo{n} where n}}}, sparams=svec(), method=rdims(Tuple{Any}, Tuple{StaticArrays.SOneTo{n} where n, Vararg{StaticArrays.SOneTo{n} where n}}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000969d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote), Any, Float64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74228826e6e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.promote), Float64, Float64}, sparams=svec(Float64), method=promote(T, T, T...) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.promote), Any, Float64}, sparams=svec(), method=promote(Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000617, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), Tuple{Any, Array{R, 1} where R<:Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422869e15a0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), Tuple{Any, Array{R, 1} where R<:Real}}, sparams=svec(), method=Typeof(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000028, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.minimum), Base.SubArray{Any, 1, P, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, false} where P<:(Array{T, 1} where T<:Real)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226d4345e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.minimum), Base.SubArray{Any, 1, P, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, false} where P<:(Array{T, 1} where T<:Real)}, sparams=svec(), method=minimum(AbstractArray{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000005a4d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.jac_coord!), Any, ADNLPModels.ADNLPModel{Float64, Array{Float64, 1}, Array{Int64, 1}}, Array{Float64, 1}, Base.SubArray{Float64, 1, Array{Float64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x74226eceed60)[ Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_coord!), ADNLPModels.SparseADJacobian{Tag, R, T, C, S} where S where C where T where R where Tag, ADNLPModels.ADNLPModel{Float64, Array{Float64, 1}, Array{Int64, 1}}, Array{Float64, 1}, Base.SubArray{Float64, 1, Array{Float64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(), method=jac_coord!(ADNLPModels.SparseADJacobian{Tag, R, T, C, S} where S where C where T where R where Tag, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_coord!), ADNLPModels.ADBackend, ADNLPModels.ADNLPModel{Float64, Array{Float64, 1}, Array{Int64, 1}}, Array{Float64, 1}, Base.SubArray{Float64, 1, Array{Float64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(), method=jac_coord!(ADNLPModels.ADBackend, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_coord!), NLPModels.AbstractNLPModel{T, S} where S where T, ADNLPModels.ADNLPModel{Float64, Array{Float64, 1}, Array{Int64, 1}}, Array{Float64, 1}, Base.SubArray{Float64, 1, Array{Float64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(), method=jac_coord!(NLPModels.AbstractNLPModel{T, S} where S where T, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T), fully_covers=false), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096b3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), Real, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.abs), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R<:Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a77c46a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), Real, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.abs), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R<:Real}}, sparams=svec(), method=combine_styles(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004832, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{RipQP.ScaleDataQP{T, S}} where S<:(AbstractArray{T, 1} where T<:Real) where T<:Real, Any, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226e8946a0)[Core.MethodMatch(spec_types=Tuple{Type{RipQP.ScaleDataQP{T, S}} where S<:(AbstractArray{T, 1} where T<:Real) where T<:Real, Any, Any}, sparams=svec(), method=(::Type{RipQP.ScaleDataQP{T<:Real, S}})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.objectid), Base.LogicalIndex{Int64, Base.BitArray{N}} where N}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742286a5fa40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.objectid), Base.LogicalIndex{Int64, Base.BitArray{N}} where N}, sparams=svec(), method=objectid(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000507, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{RipQP.InputConfig{I} where I<:Integer}, Symbol, Bool, Bool, Bool, Int64, Bool, Any, Bool, RipQP.SystemWrite}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a7e877c0)[Core.MethodMatch(spec_types=Tuple{Type{RipQP.InputConfig{I} where I<:Integer}, Symbol, Bool, Bool, Bool, Int64, Bool, Bool, Bool, RipQP.SystemWrite}, sparams=svec(Int64), method=(::Type{RipQP.InputConfig{I} where I})(Symbol, Bool, Bool, Bool, I, Bool, Bool, Bool, RipQP.SystemWrite) where {I<:Integer}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(<)), Any, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7422882787a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(<)), Any, Any}, sparams=svec(typeof(Base.:(<))), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004959, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.maybeview), Array{var"#s4711", 1} where var"#s4711"<:Float64, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226eab86e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.maybeview), Array{var"#s4711", 1} where var"#s4711"<:Float64, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(), method=maybeview(AbstractArray{T, N} where N where T, Any...), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002e4e, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unalias), Array{_A, 1} where _A, Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226ef17660)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.unalias), Array{_A, 1} where _A, Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64}}, sparams=svec(), method=unalias(Any, AbstractArray{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001307, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226e116060)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), Any, typeof(Base.:(*)), AbstractArray{T, 1} where T<:Real, Array{R, 1} where R<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(6, 0x7422889db360)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Base.Broadcast.DefaultArrayStyle{N} where N, typeof(Base.:(*)), FillArrays.AbstractZeros{T, 1, Axes} where Axes where T<:Real, Array{R, 1} where R<:Real}, sparams=svec(), method=broadcasted(Base.Broadcast.DefaultArrayStyle{N} where N, typeof(Base.:(*)), FillArrays.AbstractZeros{T, N, Axes} where Axes where N where T, AbstractArray{var"#s9", N} where N where var"#s9"<:Number), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Base.Broadcast.BroadcastStyle, typeof(Base.:(*)), AbstractArray{T, 1} where T<:Real, Array{R, 1} where R<:Real}, sparams=svec(typeof(Base.:(*))), method=broadcasted(Base.Broadcast.BroadcastStyle, F, Any...) where {F}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Any, typeof(Base.:(*)), AbstractArray{T, 1} where T<:Real, Array{R, 1} where R<:Real}, sparams=svec(F), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009681, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T}, NLPModels.NLPModelMeta{Float64, Array{Float64, 1}}, NLPModels.Counters, ADNLPModels.ADModelBackend{_A, _B, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, _C, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend} where _C where _B where _A, SolverTest.var"#47#48", Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 1}, ADNLPModels.var"#301#302"{Type{Float64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d1fc2c0)[Core.MethodMatch(spec_types=Tuple{Type{ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T}, NLPModels.NLPModelMeta{Float64, Array{Float64, 1}}, NLPModels.Counters, ADNLPModels.ADModelBackend{_A, _B, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, _C, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend} where _C where _B where _A, SolverTest.var"#47#48", Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 1}, ADNLPModels.var"#301#302"{Type{Float64}}}, sparams=svec(Float64, Array{Float64, 1}, Array{Int64, 1}), method=(::Type{ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T})(NLPModels.NLPModelMeta{T, S}, NLPModels.Counters, ADNLPModels.ADModelBackend{GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS} where HBLS where JBLS where JtvBLS where JvBLS where HvBLS where GHJ where HB where JB where JtvB where JvB where HvB where GB, Any, Si, Si, S, Any) where {T, S, Si}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096b3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{RipQP.LDLData{_A, Array{_A, 1}, Tlow, LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, S}, _B, var"#s179"}} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real where _B where S where F where T where Tlow<:Real where _A where _A, Any, RipQP.Regularization{T} where T<:Real, RipQP.FactorizationData{Tlow} where Tlow<:Real, Any, Any, Bool, Bool, LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, S} where S where F where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422712fcc00)[Core.MethodMatch(spec_types=Tuple{Type{RipQP.LDLData{_A, Array{_A, 1}, Tlow, LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, S}, _B, var"#s179"}} where var"#s179"<:RipQP.FactorizationData{Tlow} where _B<:Union{AbstractArray{_A, 2}, LinearOperators.LinearOperator{_A, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where S where F where T where Tlow<:Real where _A where _A<:Real, Any, RipQP.Regularization{T} where T<:Real, RipQP.FactorizationData{Tlow} where Tlow<:Real, Any, Any, Bool, Bool, LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, S} where S where F where T}, sparams=svec(), method=(::Type{RipQP.LDLData{T<:Real, S, Tlow, Op<:Union{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T, RipQP.LRPrecond{Op1, Op2} where Op2 where Op1}, M<:Union{AbstractArray{T<:Real, 2}, LinearOperators.LinearOperator{T<:Real, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, F<:RipQP.FactorizationData{Tlow}}})(Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.restart_copyto_nonleaf!), Base.BitArray{1}, Base.BitArray{1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Any, Int64, Base.OneTo{Int64}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422713dd760)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.restart_copyto_nonleaf!), Base.BitArray{1}, Base.BitArray{1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Any, Int64, Base.OneTo{Int64}, Int64, Int64}, sparams=svec(), method=restart_copyto_nonleaf!(Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048ef, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.deepcopy_internal), QuadraticModels.QuadraticModel{T, S, M1, M2} where M2 where M1 where S where T, Base.IdDict{Any, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a8e869c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.deepcopy_internal), QuadraticModels.QuadraticModel{T, S, M1, M2} where M2 where M1 where S where T, Base.IdDict{Any, Any}}, sparams=svec(), method=deepcopy_internal(Any, Base.IdDict{K, V} where V where K), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000066e5, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.abs), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real)}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422aaa00d00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.abs), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real)}, Tuple{Base.OneTo{Int64}}}, sparams=svec(), method=_axes(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047da, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.firstindex), Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Array{Float64, 1}}, Array{T, 1} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a7c9a6e0)[Core.MethodMatch(spec_types=Tuple{Type{Array{Float64, 1}}, Array{T, 1} where T<:Real}, sparams=svec(Float64, 1, T<:Real), method=(::Type{Array{T, N}})(AbstractArray{S, N}) where {T, N, S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010df, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.RefValue{typeof(Base.:(>))}, AbstractArray{T, N} where N where T, Float64}}, UInt64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742286b7e200)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.RefValue{typeof(Base.:(>))}, AbstractArray{T, N} where N where T, Float64}}, UInt64}, sparams=svec(), method=(::Type{MethodError})(Any, Any, UInt64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000009c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.has_fast_linear_indexing), LinearAlgebra.Symmetric{Float64, S} where S<:(AbstractArray{var"#s4711", 2} where var"#s4711"<:Float64)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422880653c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.has_fast_linear_indexing), LinearAlgebra.Symmetric{Float64, S} where S<:(AbstractArray{var"#s4711", 2} where var"#s4711"<:Float64)}, sparams=svec(), method=has_fast_linear_indexing(Union{Base.AbstractBroadcasted, AbstractArray{T, N} where N where T}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000059de, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.typeintersect), Type{Tuple{Any}}, Type{var"#s175"} where var"#s175"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64})}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d610a40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.typeintersect), Type{Tuple{Any}}, Type{var"#s175"} where var"#s175"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64})}}, sparams=svec(), method=typeintersect(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000527, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.__safe_setindex!), Array{QuadraticModels.PresolveOperation{T, S}, 1} where T<:Real where S, QuadraticModels.FreeLinearSingletonColumn{T, _A} where _A where T<:Real, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74227429dbe0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.__safe_setindex!), Array{QuadraticModels.PresolveOperation{T, S}, 1}, QuadraticModels.FreeLinearSingletonColumn{T, S}, Int64} where S where T<:Real, sparams=svec(T<:(Union{QuadraticModels.FreeLinearSingletonColumn{T, S}, QuadraticModels.PresolveOperation{T, S}} where T<:Real where S)), method=__safe_setindex!(Array{T, 1}, T, Int64) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.__safe_setindex!), Array{QuadraticModels.PresolveOperation{T, S}, 1} where T<:Real where S, QuadraticModels.FreeLinearSingletonColumn{T, _A} where _A where T<:Real, Int64}, sparams=svec(T<:(QuadraticModels.PresolveOperation{T, S} where T<:Real where S)), method=__safe_setindex!(Array{T, 1}, Any, Int64) where {T}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000111e, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.has_free_typevars), Type{Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742272fe0b60)[Core.MethodMatch(spec_types=Tuple{typeof(Core.has_free_typevars), Type{Any}}, sparams=svec(), method=has_free_typevars(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000004c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.length), Tuple{Type, typeof(DataType)}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273bd7960)[Core.MethodMatch(spec_types=Tuple{typeof(Base.length), Tuple{Type, typeof(DataType)}}, sparams=svec(), method=length(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000664, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds_indices), Type{Bool}, Tuple, Tuple{Base.IteratorsMD.CartesianIndex{2}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d395f20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds_indices), Type{Bool}, Tuple, Tuple{Base.IteratorsMD.CartesianIndex{2}}}, sparams=svec(), method=checkbounds_indices(Type{Bool}, Tuple, Tuple{Base.IteratorsMD.CartesianIndex{N} where N, Vararg}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004672, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.eltypes), Tuple{Int64, Array{R, 1} where R}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74227327a7a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.eltypes), Tuple{Int64, Array{R, 1} where R}}, sparams=svec(), method=eltypes(Tuple{Any, Any}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048ab, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{RipQP.LDLData{T, Array{T, 1}, Tlow, LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, S}, _A, RipQP.LDLFactorizationData{Tlow}}} where Tlow<:Real where _A where S where F where T where Tlow<:Real where T<:Real where T<:Real, Any, RipQP.Regularization{T} where T<:Real, RipQP.LDLFactorizationData{Tlow} where Tlow<:Real, Any, Any, Bool, Bool, LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, S} where S where F where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a94853e0)[Core.MethodMatch(spec_types=Tuple{Type{RipQP.LDLData{T, Array{T, 1}, Tlow, LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, S}, _A, RipQP.LDLFactorizationData{Tlow}}} where _A<:Union{AbstractArray{T, 2}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where S where F where T where Tlow<:Real where T<:Real where T<:Real, Any, RipQP.Regularization{T} where T<:Real, RipQP.LDLFactorizationData{Tlow} where Tlow<:Real, Any, Any, Bool, Bool, LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, S} where S where F where T}, sparams=svec(), method=(::Type{RipQP.LDLData{T<:Real, S, Tlow, Op<:Union{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T, RipQP.LRPrecond{Op1, Op2} where Op2 where Op1}, M<:Union{AbstractArray{T<:Real, 2}, LinearOperators.LinearOperator{T<:Real, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, F<:RipQP.FactorizationData{Tlow}}})(Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SolverCore.log_row), Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a9d4f6e0)[Core.MethodMatch(spec_types=Tuple{typeof(SolverCore.log_row), Any}, sparams=svec(), method=log_row(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096bd, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.isflat), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, var"#s179", typeof(Base.identity), Tuple{Int64}} where var"#s179"<:Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742289739de0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.isflat), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, var"#s179", typeof(Base.identity), Tuple{Int64}} where var"#s179"<:Tuple}, sparams=svec(), method=isflat(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000480e, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.string), String, Type{StaticArraysCore.SArray{Tuple{2}, _A, N, L} where L where N} where _A, String, Int64, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742272ea3ea0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.string), String, Type{StaticArraysCore.SArray{Tuple{2}, _A, N, L} where L where N} where _A, String, Int64, String}, sparams=svec(), method=string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003db1, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type, Memory{Symbol}}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), Tuple{typeof(DataType)}}, Type{LinearOperators.LinearOperator{Float64, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##12#PreconditionerData##13"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Nothing, Nothing, Int64, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742289f034a0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), Tuple{typeof(DataType)}}, Type{LinearOperators.LinearOperator{Float64, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##12#PreconditionerData##13"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Nothing, Nothing, Int64, Int64, Int64}, sparams=svec(Float64, Int64, F<:(RipQP.var"#PreconditionerData##12#PreconditionerData##13"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real), Nothing, Nothing), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, I, I, Bool, Bool, F, Ft, Fct, I, I, I) where {T, I<:Integer, F, Ft, Fct}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.:(>)), Tuple{Array{Int64, 1}, Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226c8e9f00)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.:(>)), Tuple{Array{Int64, 1}, Real}}, sparams=svec(typeof(Base.:(>))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b1, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.grow_to!), Base.Dict{K, V} where V where K, Tuple{Pair{Symbol, Nothing}, Vararg{Pair{A, B} where B where A}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742271a641a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.grow_to!), Base.Dict{K, V} where V where K, Tuple{Pair{Symbol, Nothing}, Vararg{Pair{A, B} where B where A}}, Int64}, sparams=svec(K, V), method=grow_to!(Base.AbstractDict{K, V}, Any, Any) where {K, V}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001784, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eachindex), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.sqrt), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real)}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742285997040)[Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.sqrt), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real)}}, sparams=svec(), method=eachindex(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047e3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{QuadraticModels.Row{Float64}}, Array{Int64, 1}, Array{Float64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422868f2ec0)[Core.MethodMatch(spec_types=Tuple{Type{QuadraticModels.Row{Float64}}, Array{Int64, 1}, Array{Float64, 1}}, sparams=svec(), method=(::Type{QuadraticModels.Row{T}})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009745, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.dict_with_eltype), Base.var"#Dict##0#Dict##1", Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Any, 1}}, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Int64, 1}}, Vararg{Pair{Symbol, _A} where _A, 4}}, Type}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x742288c56060)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.dict_with_eltype), Base.var"#Dict##0#Dict##1", Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Any, 1}}, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Int64, 1}}, Vararg{Pair{Symbol, _A} where _A, 4}}, Union{Type{Pair{K, V}}, Type{Tuple{K, V}}}} where V where K, sparams=svec(K, V), method=dict_with_eltype(Any, Any, Union{Type{Pair{K, V}}, Type{Tuple{K, V}}}) where {K, V}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.dict_with_eltype), Base.var"#Dict##0#Dict##1", Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Any, 1}}, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Int64, 1}}, Vararg{Pair{Symbol, _A} where _A, 4}}, Type}, sparams=svec(Base.var"#Dict##0#Dict##1"), method=dict_with_eltype(F, Any, Any) where {F}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000178a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.merge), NamedTuple{(:ap,), var"#s179"} where var"#s179"<:Tuple{RipQP.RipQPDoubleParameters{T, SP1, _A, RipQP.PC, RipQP.PC} where _A<:RipQP.SolverParams{T} where SP1<:(RipQP.K2LDLParams{_A, RipQP.LDLFact} where _A) where T<:Real}, Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where T<:Tuple{Vararg{Any, N}} where names where N where V}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422704d5f20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.merge), NamedTuple{(:ap,), var"#s179"} where var"#s179"<:Tuple{RipQP.RipQPDoubleParameters{T, SP1, _A, RipQP.PC, RipQP.PC} where _A<:RipQP.SolverParams{T} where SP1<:(RipQP.K2LDLParams{_A, RipQP.LDLFact} where _A) where T<:Real}, Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where T<:Tuple{Vararg{Any, N}} where names where N where V}, sparams=svec(), method=merge(NamedTuple{names, T} where T<:Tuple where names, Base.Pairs{var"#s179", var"#s178", var"#s177", var"#s176"} where var"#s176"<:(NamedTuple{names, T} where T<:Tuple where names) where var"#s177" where var"#s178" where var"#s179"), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001aa1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isbits), Base.BitArray{N} where N}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742288846b60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.isbits), Base.BitArray{N} where N}, sparams=svec(), method=isbits(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000505, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LDLFactorizations.ldl_analyze), LinearAlgebra.Symmetric{T, SparseArrays.SparseMatrixCSC{T, Int64}} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273779360)[Core.MethodMatch(spec_types=Tuple{typeof(LDLFactorizations.ldl_analyze), LinearAlgebra.Symmetric{T, SparseArrays.SparseMatrixCSC{T, Int64}}} where T<:Number, sparams=svec(T<:Number, Int64), method=ldl_analyze(LinearAlgebra.Symmetric{T, SparseArrays.SparseMatrixCSC{T, Ti}}) where {T<:Number, Ti<:Integer}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009767, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isempty), Array{Tlow, 1} where Tlow<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226ed6d960)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.isempty), Array{Tlow, 1} where Tlow<:Real}, sparams=svec(), method=isempty(AbstractArray{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012c4, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{LimitedLDLFactorizations.var"##attempt_lldl!#11", Any, Real, typeof(LimitedLDLFactorizations.attempt_lldl!), Int64, Array{Tv, 1} where Tv<:Real, Array{Tv, 1} where Tv<:Real, Array{Int64, 1}, Array{Int64, 1}, Array{Tv, 1} where Tv<:Real, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422869f83e0)[Core.MethodMatch(spec_types=Tuple{LimitedLDLFactorizations.var"##attempt_lldl!#11", Int64, Real, typeof(LimitedLDLFactorizations.attempt_lldl!), Int64, Array{Tv, 1}, Array{Tv, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Tv, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}} where Tv<:Real, sparams=svec(Ti<:Integer, Tv<:Number), method=var"#attempt_lldl!#11"(Ti, Tv, typeof(LimitedLDLFactorizations.attempt_lldl!), Int64, Array{Tv, 1}, Array{Tv, 1}, Array{Ti, 1}, Array{Ti, 1}, Array{Tv, 1}, Array{Ti, 1}, Array{Ti, 1}, Array{Ti, 1}) where {Ti<:Integer, Tv<:Number}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009769, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.allocatedinline), Type{Float32}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228b039380)[Core.MethodMatch(spec_types=Tuple{typeof(Base.allocatedinline), Type{Float32}}, 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{typeof(Base.vec), Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64}), Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d126ac0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64}), Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), AbstractArray{T, 1} where T<:Real, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7422880b95e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), AbstractArray{T, 1} where T<:Real, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"}, sparams=svec(), method=materialize!(Any, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), AbstractArray{T, 1} where T<:Real, Any}, sparams=svec(), method=materialize!(Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048be, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), Any, typeof(Base.:(*)), Any, Array{R, 1} where R<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(6, 0x74228a5eac80)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Base.Broadcast.DefaultArrayStyle{N} where N, typeof(Base.:(*)), FillArrays.AbstractZeros{T, N, Axes} where Axes where N where T, Array{R, 1} where R<:Real}, sparams=svec(), method=broadcasted(Base.Broadcast.DefaultArrayStyle{N} where N, typeof(Base.:(*)), FillArrays.AbstractZeros{T, N, Axes} where Axes where N where T, AbstractArray{var"#s9", N} where N where var"#s9"<:Number), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Base.Broadcast.BroadcastStyle, typeof(Base.:(*)), Any, Array{R, 1} where R<:Real}, sparams=svec(typeof(Base.:(*))), method=broadcasted(Base.Broadcast.BroadcastStyle, F, Any...) where {F}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Any, typeof(Base.:(*)), Any, Array{R, 1} where R<:Real}, sparams=svec(F), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009681, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{SparseArrays.var"#dropzeros!##0#dropzeros!##1", Int64, Int64, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228afb0840)[Core.MethodMatch(spec_types=Tuple{SparseArrays.var"#dropzeros!##0#dropzeros!##1", Int64, Int64, Any}, sparams=svec(), method=var"#dropzeros!##0"(Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009675, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.map), typeof(tuple), Tuple{Any, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422746103e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.map), typeof(tuple), Tuple{Any, Any}}, sparams=svec(), method=map(Any, Tuple{Any, Any}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006bd, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.prod), StaticArraysCore.Size{S} where S}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742282cbda40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.prod), StaticArraysCore.Size{S} where S}, sparams=svec(S), method=prod(StaticArraysCore.Size{S}) where {S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000969d, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.sqrt), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R<:Real}}}, UInt64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228699efa0)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.sqrt), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R<:Real}}}, UInt64}, sparams=svec(), method=(::Type{MethodError})(Any, Any, UInt64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000009c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.BitMaskedBitArray{_A, _B}} where _B where _A, Base.BitArray{N} where N, Base.BitArray{N} where N}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a7d569e0)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.BitMaskedBitArray{_A, _B}} where _B where _A, Base.BitArray{N} where N, Base.BitArray{N} where N}, sparams=svec(_A, _B), method=(::Type{Base.Broadcast.BitMaskedBitArray{N, M}})(Any, Any) where {N, M}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004934, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IndexStyle}, Array{T, 1} where T<:Number}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226d184c60)[ Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Array{T, 1} where T<:Number}, sparams=svec(), method=(::Type{Base.IndexStyle})(AbstractArray{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000fa4, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IteratorSize}, NTuple{5, Pair{Symbol, String}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228a52e860)[Core.MethodMatch(spec_types=Tuple{Type{Base.IteratorSize}, NTuple{5, Pair{Symbol, String}}}, sparams=svec(), method=(::Type{Base.IteratorSize})(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000445, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseArrays.CHOLMOD.xdtyp), Type{Float32}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226cedeaa0)[Core.MethodMatch(spec_types=Tuple{typeof(SparseArrays.CHOLMOD.xdtyp), Type{Float32}}, sparams=svec(Float32), method=xdtyp(Type{T}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009675, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{QuadraticModels.QPData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S where T}, Any, Any, LinearOperators.LinearOperator{T, I, F, Ft, Fct, T} where T where Fct<:(LinearOperators.var"#ctprod!#140"{var"#s179"} where var"#s179"<:Tuple{Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T, LinearOperators.LinearOperator{_A, Int64, LinearOperators.var"#119#120", LinearOperators.var"#119#120", LinearOperators.var"#119#120", T} where T where _A}) where Ft<:(LinearOperators.var"#tprod!#139"{var"#s179"} where var"#s179"<:Tuple{Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T, LinearOperators.LinearOperator{_A, Int64, LinearOperators.var"#119#120", LinearOperators.var"#119#120", LinearOperators.var"#119#120", T} where T where _A}) where F<:(LinearOperators.var"#prod!#138"{var"#s179"} where var"#s179"<:Tuple{Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T, LinearOperators.LinearOperator{_A, Int64, LinearOperators.var"#119#120", LinearOperators.var"#119#120", LinearOperators.var"#119#120", T} where T where _A}) where I<:Integer where T, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a764e700)[Core.MethodMatch(spec_types=Tuple{Type{QuadraticModels.QPData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S where T}, Any, Any, LinearOperators.LinearOperator{T, I, F, Ft, Fct, T} where T where Fct<:(LinearOperators.var"#ctprod!#140"{var"#s179"} where var"#s179"<:Tuple{Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T, LinearOperators.LinearOperator{_A, Int64, LinearOperators.var"#119#120", LinearOperators.var"#119#120", LinearOperators.var"#119#120", T} where T where _A}) where Ft<:(LinearOperators.var"#tprod!#139"{var"#s179"} where var"#s179"<:Tuple{Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T, LinearOperators.LinearOperator{_A, Int64, LinearOperators.var"#119#120", LinearOperators.var"#119#120", LinearOperators.var"#119#120", T} where T where _A}) where F<:(LinearOperators.var"#prod!#138"{var"#s179"} where var"#s179"<:Tuple{Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T, LinearOperators.LinearOperator{_A, Int64, LinearOperators.var"#119#120", LinearOperators.var"#119#120", LinearOperators.var"#119#120", T} where T where _A}) where I<:Integer where T, Any}, sparams=svec(), method=(::Type{QuadraticModels.QPData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S where T})(Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009745, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.map), Base.var"#view##0#view##1"{Base.BitArray{N}} where N, Tuple{Base.LogicalIndex{Int64, Base.BitArray{N}} where N}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228a88f260)[Core.MethodMatch(spec_types=Tuple{typeof(Base.map), Base.var"#view##0#view##1"{Base.BitArray{N}} where N, Tuple{Base.LogicalIndex{Int64, Base.BitArray{N}} where N}}, sparams=svec(), method=map(Any, Tuple{Any}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006bc, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.RefValue{T} where T}, typeof(Base.max)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228a109c20)[Core.MethodMatch(spec_types=Tuple{Type{Base.RefValue{T} where T}, typeof(Base.max)}, sparams=svec(typeof(Base.max)), 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.checkbounds), Type{Bool}, LinearAlgebra.Diagonal{T, Union{}} where T<:Real, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228f361a00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Type{Bool}, LinearAlgebra.Diagonal{T, Union{}} where T<:Real, Int64, Int64}, sparams=svec(), method=checkbounds(Type{Bool}, AbstractArray{T, N} where N where T, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001279, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{AbstractArray{Float64, 1}, Array{Float64, 1}} where var"#s175"<:Tuple{AbstractArray{Float64, 1}, Array{Float64, 1}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a7aa8d00)[Core.MethodMatch(spec_types=Tuple{Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{AbstractArray{Float64, 1}, Array{Float64, 1}} where var"#s175"<:Tuple{AbstractArray{Float64, 1}, Array{Float64, 1}}, Int64}, sparams=svec(var"#s175"<:Tuple{AbstractArray{Float64, 1}, Array{Float64, 1}}), method=(::Base.var"#cvt1#convert##0"{T, x})(Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000376, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.ht_keyindex2_shorthash!), Base.Dict{K, V} where V where K, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a777a2c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.ht_keyindex2_shorthash!), Base.Dict{K, V} where V where K, Any}, sparams=svec(K, V), method=ht_keyindex2_shorthash!(Base.Dict{K, V}, Any) where {K, V}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000034d3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{NLPModels.NLPModelMeta{_A, _B}} where _B where _A, Int64, Any, Any, Any, Any, Any, Any, Any, Any, Any, Int64, Int64, Int64, Real, Any, Any, Any, Any, Any, Any, Any, Any, Any, Int64, Any, Int64, Any, Any, Int64, Any, Array{Int64, 1}, Any, Bool, Bool, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74227155bea0)[Core.MethodMatch(spec_types=Tuple{Type{NLPModels.NLPModelMeta{_A, _B}} where _B where _A, Int64, Any, Any, Any, Any, Any, Any, Any, Any, Any, Int64, Int64, Int64, Real, Any, Any, Any, Any, Any, Any, Any, Any, Any, Int64, Any, Int64, Any, Any, Int64, Any, Array{Int64, 1}, Any, Bool, Bool, String}, sparams=svec(), method=(::Type{NLPModels.NLPModelMeta{T, S}})(Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096b0, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{RipQP.var"##RipQPSolver#125", Base.Pairs{Symbol, Any, NTuple{4, Symbol}, NamedTuple{(:history, :scaling, :display, :mode), Tuple{Bool, Bool, Bool, Symbol}}}, typeof(RipQP.RipQPSolver), QuadraticModels.QuadraticModel{Float64, S, M1, M2} where M2 where M1 where S, RipQP.RipQPDoubleParameters{Float64, RipQP.K2LDLParams{Float64, RipQP.LDLFact}, _A, RipQP.PC, RipQP.PC} where _A<:RipQP.SolverParams{Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742272354540)[Core.MethodMatch(spec_types=Tuple{RipQP.var"##RipQPSolver#125", Base.Pairs{Symbol, Any, NTuple{4, Symbol}, NamedTuple{(:history, :scaling, :display, :mode), Tuple{Bool, Bool, Bool, Symbol}}}, typeof(RipQP.RipQPSolver), QuadraticModels.QuadraticModel{Float64, S, M1, M2} where M2 where M1 where S, RipQP.RipQPDoubleParameters{Float64, RipQP.K2LDLParams{Float64, RipQP.LDLFact}, _A, RipQP.PC, RipQP.PC} where _A<:RipQP.SolverParams{Float64}}, sparams=svec(Float64), method=var"#RipQPSolver#125"(Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where T<:Tuple{Vararg{Any, N}} where names where N where V, typeof(RipQP.RipQPSolver), QuadraticModels.AbstractQuadraticModel{T, S} where S, RipQP.RipQPDoubleParameters{T, SP1, SP2, SM1, SM2} where SM2<:RipQP.SolveMethod where SM1<:RipQP.SolveMethod where SP2<:RipQP.SolverParams{T} where SP1<:(RipQP.SolverParams{T} where T)) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.SubArray{_A, 1, P, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, false}} where P<:(Array{Tv, 1} where Tv) where _A, Array{Tv, 1} where Tv, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226db31020)[Core.MethodMatch(spec_types=Tuple{Type{Base.SubArray{_A, 1, P, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, false}} where P<:(Array{Tv, 1} where Tv) where _A, Array{Tv, 1} where Tv, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, Int64, Int64}, sparams=svec(_A, 1, P<:(Array{Tv, 1} where Tv), Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, false), method=(::Type{Base.SubArray{T, N, P, I, L}})(Any, Any, Any, Any) where {T, N, P, I, L}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002d90, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, L} where L<:Integer}, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Integer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228b021a00)[Core.MethodMatch(spec_types=Tuple{Type{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, L} where L<:Integer}, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Integer, Int64}, sparams=svec(Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}), method=(::Type{Base.StepRangeLen{T, R, S, L} where L<:Integer})(R, S, Integer, Integer) where {T, R, S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000008b3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.Broadcast.Broadcasted{var"#s179", Nothing, typeof(Base.sqrt), var"#s179"} where var"#s179"<:Tuple{AbstractArray{T, 1} where T<:Real} where var"#s179"<:Base.Broadcast.BroadcastStyle}}, UInt64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226bff7b40)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.Broadcast.Broadcasted{var"#s179", Nothing, typeof(Base.sqrt), var"#s179"} where var"#s179"<:Tuple{AbstractArray{T, 1} where T<:Real} where var"#s179"<:Base.Broadcast.BroadcastStyle}}, UInt64}, sparams=svec(), method=(::Type{MethodError})(Any, Any, UInt64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000009c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.length), Array{_A, 1} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742284053bc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.length), Array{_A, 1} where _A}, sparams=svec(_A), method=length(Array{T, 1}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000030c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), Base.BitArray{1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(*)), var"#s179"} where var"#s179"<:Tuple{Int64, Array{R, 1} where R}}, limit=1), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x742285c07a20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.copyto!), Base.BitArray{1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(*)), var"#s179"} where var"#s179"<:Tuple{Int64, Array{R, 1} where R}}, sparams=svec(), method=copyto!(AbstractArray{T, N} where N where T, Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048c4, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.update_preconditioner!), RipQP.PreconditionerData{T, S} where S where T<:Real, RipQP.PreallocatedDataK2Krylov{T, S, M, MT, Pr, Ksol} where Ksol<:(Krylov.KrylovWorkspace{T, FC, S} where S where FC where T) where Pr<:(RipQP.PreconditionerData{T, S} where S where T<:Real) where MT<:Union{Int64, RipQP.MatrixTools{T}} where M<:Union{AbstractArray{T, 2}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where S where T<:Real, RipQP.IterData{T, S} where S where T<:Real, RipQP.Point{T, S} where S<:AbstractArray{T, 1} where T<:Real where T<:Real, RipQP.QM_IntData, RipQP.QM_FloatData_ref{T, _A, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where _A where T<:Real, RipQP.Counters}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74227469fe00)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.update_preconditioner!), RipQP.LDLData{T, S, Tlow, Op, M, F} where F<:RipQP.FactorizationData{Tlow} where M<:Union{AbstractArray{T, 2}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where Op<:Union{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T, RipQP.LRPrecond{Op1, Op2} where Op2 where Op1} where Tlow where S, RipQP.PreallocatedDataK2Krylov{T, S, M, MT, Pr, Ksol} where Ksol<:(Krylov.KrylovWorkspace{T, FC, S} where S where FC where T) where Pr<:(RipQP.PreconditionerData{T, S} where S where T<:Real) where MT<:Union{Int64, RipQP.MatrixTools{T}} where M<:Union{AbstractArray{T, 2}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where S, RipQP.IterData{T, S} where S, RipQP.Point{T, S} where S<:AbstractArray{T, 1} where T<:Real, RipQP.QM_IntData, RipQP.QM_FloatData_ref{T, _A, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where _A, RipQP.Counters} where T<:Real, sparams=svec(T<:Real), method=update_preconditioner!(RipQP.LDLData{T, S, Tlow, Op, M, F} where F<:RipQP.FactorizationData{Tlow} where M<:Union{AbstractArray{T, 2}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where Op<:Union{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T, RipQP.LRPrecond{Op1, Op2} where Op2 where Op1} where Tlow where S, RipQP.PreallocatedData{T, S} where S, RipQP.IterData{T, S} where S, RipQP.Point{T, S} where S, RipQP.QM_IntData, RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S, RipQP.Counters) where {T<:Real}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._setindex!), Base.IndexLinear, LinearAlgebra.Adjoint{Float64, Array{Float64, 1}}, Any, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74228b5b4820)[ Core.MethodMatch(spec_types=Tuple{typeof(Base._setindex!), Base.IndexLinear, LinearAlgebra.Adjoint{Float64, Array{Float64, 1}}, Any, Int64, Int64}, sparams=svec(2), method=_setindex!(Base.IndexLinear, AbstractArray{T, N} where N where T, Any, Vararg{Int64, M}) where {M}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001301, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setproperty!), RipQP.Regularization{T} where T<:Real, Symbol, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a953bdc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.setproperty!), RipQP.Regularization{T} where T<:Real, Symbol, Any}, sparams=svec(), method=setproperty!(Any, Symbol, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000284, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), var"#s179"} where var"#s179"<:Tuple{Type}, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where T, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##4#PreconditionerData##5"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real, Nothing, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d4520a0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), var"#s179"} where var"#s179"<:Tuple{Type}, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where T, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##4#PreconditionerData##5"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real, Nothing, Nothing}, sparams=svec(T, Int64), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, I, I, Bool, Bool, Any, Any, Any) where {T, I<:Integer}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IndexStyle}, Base.SubArray{_A, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{_A, 1} where _A) where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x742288513c60)[ Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Base.SubArray{_A, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{_A, 1} where _A) where _A}, sparams=svec(), method=(::Type{Base.IndexStyle})(AbstractArray{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000fa4, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.vector_mode_dual_eval!), Any, ForwardDiff.JacobianConfig{Nothing, Float64, _A, Array{ForwardDiff.Dual{Nothing, Float64, _A}, 1}} where _A where _A, Array{Float64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422749d64a0)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.vector_mode_dual_eval!), Any, ForwardDiff.JacobianConfig{Nothing, Float64, _A, Array{ForwardDiff.Dual{Nothing, Float64, _A}, 1}} where _A where _A, Array{Float64, 1}}, sparams=svec(F), method=vector_mode_dual_eval!(F, Union{ForwardDiff.GradientConfig{T, V, N, D} where D where N where V where T, ForwardDiff.JacobianConfig{T, V, N, D} where D where N where V where T}, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009697, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.status_to_char), Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LinearAlgebra.diag), LinearAlgebra.Diagonal{T, Union{}} where T<:Real, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226ec103e0)[ Core.MethodMatch(spec_types=Tuple{typeof(LinearAlgebra.diag), LinearAlgebra.Diagonal{T, Union{}} where T<:Real, Int64}, sparams=svec(T<:Real), method=diag(LinearAlgebra.Diagonal{T, var"#s9"} where var"#s9"<:(FillArrays.AbstractFill{T, 1, Axes} where Axes), Integer) where {T<:Number}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009681, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.write_system), RipQP.SystemWrite, LinearAlgebra.Symmetric{T, _B} where _B<:AbstractArray{T, 2} where T<:Real, Any, Symbol, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a9d8f540)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.write_system), RipQP.SystemWrite, LinearAlgebra.Symmetric{T, SparseArrays.SparseMatrixCSC{T, Int64}}, Array{T, 1}, Symbol, Int64} where T<:Real, sparams=svec(T<:Real), method=write_system(RipQP.SystemWrite, LinearAlgebra.Symmetric{T, SparseArrays.SparseMatrixCSC{T, Int64}}, Array{T, 1}, Symbol, Int64) where {T<:Real}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.abs), Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7422745af920)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.abs), Any}, sparams=svec(typeof(Base.abs)), method=broadcasted(F, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004958, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, _A}} where _A where Fct<:(LinearOperators.var"#hcat##4#hcat##5"{var"#s179", LinearOperators.LinearOperator{_A, Int64, QuadraticModels.var"#opPermutedMinusOnes##0#opPermutedMinusOnes##1"{Array{Int64, 1}}, QuadraticModels.var"#opPermutedMinusOnes##2#opPermutedMinusOnes##3"{Array{Int64, 1}}, Nothing, T}, _A, Int64} where _A where T where _A where var"#s179"<:LinearOperators.AbstractLinearOperator{T} where T) where Ft<:(LinearOperators.var"#hcat##2#hcat##3"{var"#s179", LinearOperators.LinearOperator{_A, Int64, QuadraticModels.var"#opPermutedMinusOnes##0#opPermutedMinusOnes##1"{Array{Int64, 1}}, QuadraticModels.var"#opPermutedMinusOnes##2#opPermutedMinusOnes##3"{Array{Int64, 1}}, Nothing, T}, _A, Int64} where _A where T where _A where var"#s179"<:LinearOperators.AbstractLinearOperator{T} where T) where F<:(LinearOperators.var"#hcat##0#hcat##1"{var"#s179", LinearOperators.LinearOperator{_A, Int64, QuadraticModels.var"#opPermutedMinusOnes##0#opPermutedMinusOnes##1"{Array{Int64, 1}}, QuadraticModels.var"#opPermutedMinusOnes##2#opPermutedMinusOnes##3"{Array{Int64, 1}}, Nothing, T}, _A, Int64} where _A where T where _A where var"#s179"<:LinearOperators.AbstractLinearOperator{T} where T) where I<:Integer where T, Integer, Integer, Bool, Bool, LinearOperators.var"#hcat##0#hcat##1"{var"#s179", LinearOperators.LinearOperator{_A, Int64, QuadraticModels.var"#opPermutedMinusOnes##0#opPermutedMinusOnes##1"{Array{Int64, 1}}, QuadraticModels.var"#opPermutedMinusOnes##2#opPermutedMinusOnes##3"{Array{Int64, 1}}, Nothing, T}, _A, Int64} where _A where T where _A where var"#s179"<:LinearOperators.AbstractLinearOperator{T} where T, LinearOperators.var"#hcat##2#hcat##3"{var"#s179", LinearOperators.LinearOperator{_A, Int64, QuadraticModels.var"#opPermutedMinusOnes##0#opPermutedMinusOnes##1"{Array{Int64, 1}}, QuadraticModels.var"#opPermutedMinusOnes##2#opPermutedMinusOnes##3"{Array{Int64, 1}}, Nothing, T}, _A, Int64} where _A where T where _A where var"#s179"<:LinearOperators.AbstractLinearOperator{T} where T, LinearOperators.var"#hcat##4#hcat##5"{var"#s179", LinearOperators.LinearOperator{_A, Int64, QuadraticModels.var"#opPermutedMinusOnes##0#opPermutedMinusOnes##1"{Array{Int64, 1}}, QuadraticModels.var"#opPermutedMinusOnes##2#opPermutedMinusOnes##3"{Array{Int64, 1}}, Nothing, T}, _A, Int64} where _A where T where _A where var"#s179"<:LinearOperators.AbstractLinearOperator{T} where T, Int64, Int64, Int64, Bool, Bool, Any, Any, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d61e4e0)[Core.MethodMatch(spec_types=Tuple{Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, _A}} where _A where Fct<:(LinearOperators.var"#hcat##4#hcat##5"{var"#s179", LinearOperators.LinearOperator{_A, Int64, QuadraticModels.var"#opPermutedMinusOnes##0#opPermutedMinusOnes##1"{Array{Int64, 1}}, QuadraticModels.var"#opPermutedMinusOnes##2#opPermutedMinusOnes##3"{Array{Int64, 1}}, Nothing, T}, _A, Int64} where _A where T where _A where var"#s179"<:LinearOperators.AbstractLinearOperator{T} where T) where Ft<:(LinearOperators.var"#hcat##2#hcat##3"{var"#s179", LinearOperators.LinearOperator{_A, Int64, QuadraticModels.var"#opPermutedMinusOnes##0#opPermutedMinusOnes##1"{Array{Int64, 1}}, QuadraticModels.var"#opPermutedMinusOnes##2#opPermutedMinusOnes##3"{Array{Int64, 1}}, Nothing, T}, _A, Int64} where _A where T where _A where var"#s179"<:LinearOperators.AbstractLinearOperator{T} where T) where F<:(LinearOperators.var"#hcat##0#hcat##1"{var"#s179", LinearOperators.LinearOperator{_A, Int64, QuadraticModels.var"#opPermutedMinusOnes##0#opPermutedMinusOnes##1"{Array{Int64, 1}}, QuadraticModels.var"#opPermutedMinusOnes##2#opPermutedMinusOnes##3"{Array{Int64, 1}}, Nothing, T}, _A, Int64} where _A where T where _A where var"#s179"<:LinearOperators.AbstractLinearOperator{T} where T) where I<:Integer where T, Integer, Integer, Bool, Bool, LinearOperators.var"#hcat##0#hcat##1"{var"#s179", LinearOperators.LinearOperator{_A, Int64, QuadraticModels.var"#opPermutedMinusOnes##0#opPermutedMinusOnes##1"{Array{Int64, 1}}, QuadraticModels.var"#opPermutedMinusOnes##2#opPermutedMinusOnes##3"{Array{Int64, 1}}, Nothing, T}, _A, Int64} where _A where T where _A where var"#s179"<:LinearOperators.AbstractLinearOperator{T} where T, LinearOperators.var"#hcat##2#hcat##3"{var"#s179", LinearOperators.LinearOperator{_A, Int64, QuadraticModels.var"#opPermutedMinusOnes##0#opPermutedMinusOnes##1"{Array{Int64, 1}}, QuadraticModels.var"#opPermutedMinusOnes##2#opPermutedMinusOnes##3"{Array{Int64, 1}}, Nothing, T}, _A, Int64} where _A where T where _A where var"#s179"<:LinearOperators.AbstractLinearOperator{T} where T, LinearOperators.var"#hcat##4#hcat##5"{var"#s179", LinearOperators.LinearOperator{_A, Int64, QuadraticModels.var"#opPermutedMinusOnes##0#opPermutedMinusOnes##1"{Array{Int64, 1}}, QuadraticModels.var"#opPermutedMinusOnes##2#opPermutedMinusOnes##3"{Array{Int64, 1}}, Nothing, T}, _A, Int64} where _A where T where _A where var"#s179"<:LinearOperators.AbstractLinearOperator{T} where T, Int64, Int64, Int64, Bool, Bool, Any, Any, Bool}, sparams=svec(), method=(::Type{LinearOperators.LinearOperator{T, I<:Integer, F, Ft, Fct, S}})(Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, typeof(Base.max), Tuple{Any, Any, Int64}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422896ae760)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, typeof(Base.max), Tuple{Any, Any, Int64}, Nothing}, sparams=svec(typeof(Base.max)), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.imag), var"#s179"} where var"#s179"<:Tuple{Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64}}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a9486060)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.imag), var"#s179"} where var"#s179"<:Tuple{Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64}}, Tuple{Base.OneTo{Int64}}}, sparams=svec(), method=_axes(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047da, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{QuadraticModels.QPData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S where T}, Any, Array{_A, 1} where _A, SparseMatricesCOO.SparseMatrixCOO{Tv, Int64} where Tv, SparseMatricesCOO.SparseMatrixCOO{Tv, Int64} where Tv}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e2ea700)[Core.MethodMatch(spec_types=Tuple{Type{QuadraticModels.QPData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S where T}, Any, Array{_A, 1} where _A, SparseMatricesCOO.SparseMatrixCOO{Tv, Int64} where Tv, SparseMatricesCOO.SparseMatrixCOO{Tv, Int64} where Tv}, sparams=svec(), method=(::Type{QuadraticModels.QPData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S where T})(Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009745, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.length), Tuple{Int64, Any, Any, Any, Any, Real, Real, Any, Real, Real, Int64, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228f5d6080)[Core.MethodMatch(spec_types=Tuple{typeof(Base.length), Tuple{Int64, Any, Any, Any, Any, Real, Real, Any, Real, Real, Int64, Any}}, sparams=svec(), method=length(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000664, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.merge_types), Tuple{Vararg{Symbol}}, Type{NamedTuple{(:ap,), var"#s179"}} where var"#s179"<:Tuple{RipQP.RipQPMonoParameters{T, _A, RipQP.PC} where _A<:RipQP.SolverParams{T} where T<:Real}, Type{NamedTuple{names, T}} where T<:Tuple{Vararg{Any, N}} where names where N}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228a1ad4a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.merge_types), Tuple{Vararg{Symbol}}, Type{NamedTuple{(:ap,), var"#s179"}} where var"#s179"<:Tuple{RipQP.RipQPMonoParameters{T, _A, RipQP.PC} where _A<:RipQP.SolverParams{T} where T<:Real}, Type{NamedTuple{names, T}} where T<:Tuple{Vararg{Any, N}} where names where N}, sparams=svec(), method=merge_types(Tuple{Vararg{Symbol}}, Type{var"#s179"} where var"#s179"<:(NamedTuple{names, T} where T<:Tuple where names), Type{var"#s178"} where var"#s178"<:(NamedTuple{names, T} where T<:Tuple where names)), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001a97, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.typeintersect), Type{Tuple{Any, Any, Any}}, Type{var"#s175"} where var"#s175"<:Tuple{Base.RefValue{typeof(Base.:(>))}, Array{T, N} where N where T, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742271a6ff20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.typeintersect), Type{Tuple{Any, Any, Any}}, Type{var"#s175"} where var"#s175"<:Tuple{Base.RefValue{typeof(Base.:(>))}, Array{T, N} where N where T, Any}}, sparams=svec(), method=typeintersect(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000527, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), Tuple{AbstractArray{Float64, 1}, AbstractArray{Float64, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228348c120)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), Tuple{AbstractArray{Float64, 1}, AbstractArray{Float64, 1}}}, sparams=svec(), method=Typeof(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000028, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.__safe_setindex!), Array{ReverseDiff.AbstractInstruction, 1}, ReverseDiff.SpecialInstruction{typeof(Base.convert), I, O, Nothing} where O<:Real where I<:Real, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7422894d8c60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.__safe_setindex!), Array{ReverseDiff.AbstractInstruction, 1}, ReverseDiff.SpecialInstruction{typeof(Base.convert), I, O, Nothing} where O<:Real where I<:Real, Int64}, sparams=svec(ReverseDiff.AbstractInstruction), method=__safe_setindex!(Array{T, 1}, T, Int64) where {T}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000111d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#promote_typeof##0#promote_typeof##1", Type, Tuple{String, typeof(JSOSolvers.R2)}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228eff0f80)[Core.MethodMatch(spec_types=Tuple{Base.var"#promote_typeof##0#promote_typeof##1", Type, Tuple{String, typeof(JSOSolvers.R2)}}, sparams=svec(T), method=var"#promote_typeof##0"(Type{T}, Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000060e, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(+)), Any, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422866f0360)[Core.MethodMatch(spec_types=Tuple{typeof(Base.:(+)), Any, Int64, Int64}, sparams=svec(), method=+(Any, Any, Any, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000bf1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{RipQP.StopCrit{Float64}, RipQP.QM_FloatData{T, S, M1, M2} where M2 where M1 where S where T<:Real, RipQP.QM_IntData, RipQP.Tolerances{T} where T<:Real, Union{RipQP.Residuals{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T<:Real where T<:Real, RipQP.ResidualsHistory{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T<:Real where T<:Real}, Union{RipQP.IterDataCPU{T, _A} where _A where T<:Real, RipQP.IterDataGPU{T, _A} where _A where T<:Real}, RipQP.Point{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T<:Real where T<:Real, Union{RipQP.ScaleDataLP{T, _A} where _A where T<:Real, RipQP.ScaleDataQP{T, _A} where _A where T<:Real}, RipQP.StartingPointData{T, S} where S where T<:Real, RipQP.Counters}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742270b72fe0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{RipQP.StopCrit{Float64}, RipQP.QM_FloatData{T, S, M1, M2} where M2 where M1 where S where T<:Real, RipQP.QM_IntData, RipQP.Tolerances{T} where T<:Real, Union{RipQP.Residuals{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T<:Real where T<:Real, RipQP.ResidualsHistory{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T<:Real where T<:Real}, Union{RipQP.IterDataCPU{T, _A} where _A where T<:Real, RipQP.IterDataGPU{T, _A} where _A where T<:Real}, RipQP.Point{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T<:Real where T<:Real, Union{RipQP.ScaleDataLP{T, _A} where _A where T<:Real, RipQP.ScaleDataQP{T, _A} where _A where T<:Real}, RipQP.StartingPointData{T, S} where S where T<:Real, RipQP.Counters}, Int64, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000689, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IndexStyle}, LinearAlgebra.Diagonal{T, V} where V<:Array{T, 1} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226ec1c4a0)[ Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, LinearAlgebra.Diagonal{T, V} where V<:Array{T, 1} where T<:Real}, sparams=svec(), method=(::Type{Base.IndexStyle})(AbstractArray{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000fa4, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), Array{T, 1} where T<:Real, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.sqrt), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R<:Real}}, limit=1), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226ecd0520)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.copyto!), Array{T, 1} where T<:Real, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.sqrt), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R<:Real}}, sparams=svec(), method=copyto!(AbstractArray{T, N} where N where T, Base.Broadcast.Broadcasted{Nothing, Axes, F, Args} where Args<:Tuple where F where Axes), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048d0, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), AbstractArray{Bool, N} where N, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.require_one_based_indexing), AbstractArray{T, 2} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742285da6200)[Core.MethodMatch(spec_types=Tuple{typeof(Base.require_one_based_indexing), AbstractArray{T, 2} where T}, sparams=svec(), method=require_one_based_indexing(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001235, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.map), Base.var"#view##0#view##1"{Base.SubArray{T, N, P, I, L}} where L where I where P where N where T, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.string), String, Type{StaticArraysCore.SArray{Tuple{1}, _A, N, L} where L where N} where _A, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226fcf61a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.string), String, Type{StaticArraysCore.SArray{Tuple{1}, _A, N, L} where L where N} where _A, String}, sparams=svec(), method=string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003db1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setproperty!), Any, Symbol, Bool}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{AbstractArray{T, 1} where T, Array{T, 1} where T<:Number} where var"#s175"<:Tuple{AbstractArray{T, 1} where T, Array{T, 1} where T<:Number}, Base.Val{2}}, limit=5), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742271a97b20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{AbstractArray{T, 1} where T, Array{T, 1} where T<:Number} where var"#s175"<:Tuple{AbstractArray{T, 1} where T, Array{T, 1} where T<:Number}, Base.Val{2}}, sparams=svec(), method=ntuple(Any, Base.Val{2}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000017db, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.length), Type{StaticArraysCore.SArray{Tuple{1}, _A, N, L} where L where N} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226fb48200)[Core.MethodMatch(spec_types=Tuple{typeof(Base.length), Type{StaticArraysCore.SArray{Tuple{1}, _A, N, L} where L where N} where _A}, sparams=svec(SA<:(StaticArraysCore.SArray{Tuple{1}, _A, N, L} where L where N where _A)), method=length(Type{SA}) where {SA<:(Union{LinearAlgebra.Adjoint{T, var"#s5"} where var"#s5"<:Union{StaticArraysCore.StaticArray{Tuple{var"#s2"}, T, 1} where var"#s2", StaticArraysCore.StaticArray{Tuple{var"#s3", var"#s4"}, T, 2} where var"#s4" where var"#s3"}, LinearAlgebra.Diagonal{T, var"#s12"} where var"#s12"<:(StaticArraysCore.StaticArray{Tuple{var"#s13"}, T, 1} where var"#s13"), LinearAlgebra.Hermitian{T, var"#s9"} where var"#s9"<:(StaticArraysCore.StaticArray{Tuple{var"#s10", var"#s11"}, T, 2} where var"#s11" where var"#s10"), LinearAlgebra.LowerTriangular{T, var"#s17"} where var"#s17"<:(StaticArraysCore.StaticArray{Tuple{var"#s18", var"#s19"}, T, 2} where var"#s19" where var"#s18"), LinearAlgebra.Symmetric{T, var"#s6"} where var"#s6"<:(StaticArraysCore.StaticArray{Tuple{var"#s7", var"#s8"}, T, 2} where var"#s8" where var"#s7"), LinearAlgebra.Transpose{T, var"#s1"} where var"#s1"<:Union{StaticArraysCore.StaticArray{Tuple{var"#s2"}, T, 1} where var"#s2", StaticArraysCore.StaticArray{Tuple{var"#s3", var"#s4"}, T, 2} where var"#s4" where var"#s3"}, LinearAlgebra.UnitLowerTriangular{T, var"#s23"} where var"#s23"<:(StaticArraysCore.StaticArray{Tuple{var"#s24", var"#s25"}, T, 2} where var"#s25" where var"#s24"), LinearAlgebra.UnitUpperTriangular{T, var"#s20"} where var"#s20"<:(StaticArraysCore.StaticArray{Tuple{var"#s21", var"#s22"}, T, 2} where var"#s22" where var"#s21"), LinearAlgebra.UpperTriangular{T, var"#s14"} where var"#s14"<:(StaticArraysCore.StaticArray{Tuple{var"#s15", var"#s16"}, T, 2} where var"#s16" where var"#s15"), StaticArraysCore.StaticArray{Tuple{var"#s25"}, T, 1} where var"#s25", StaticArraysCore.StaticArray{Tuple{var"#s4", var"#s3"}, T, 2} where var"#s3" where var"#s4", StaticArraysCore.StaticArray{var"#s25", T, N} where N where var"#s25"<:Tuple} 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), Array{Tv, 1} where Tv, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(>)), Signed, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.kwerr), NamedTuple{names, T} where T<:Tuple where names, Type{RipQP.RipQPMonoSolver{T, S, I, QMType, Sd, Tsc, QMfd, Pfd} where Pfd<:(RipQP.PreallocatedFloatData{T, S, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T, S} where Dda<:RipQP.DescentDirectionAllocs{T, S} where Res<:RipQP.AbstractResiduals{T, S}) where QMfd<:(RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where Tsc<:Real where Sd<:RipQP.ScaleData{T, S} where QMType<:QuadraticModels.AbstractQuadraticModel{T, S} where I where S where T}, QuadraticModels.QuadraticModel{T, S, M1, M2} where M2 where M1 where S<:AbstractArray{T, 1} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d4fade0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.kwerr), NamedTuple{names, T} where T<:Tuple where names, Type{RipQP.RipQPMonoSolver{T, S, I, QMType, Sd, Tsc, QMfd, Pfd} where Pfd<:(RipQP.PreallocatedFloatData{T, S, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T, S} where Dda<:RipQP.DescentDirectionAllocs{T, S} where Res<:RipQP.AbstractResiduals{T, S}) where QMfd<:(RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where Tsc<:Real where Sd<:RipQP.ScaleData{T, S} where QMType<:QuadraticModels.AbstractQuadraticModel{T, S} where I where S where T}, QuadraticModels.QuadraticModel{T, S, M1, M2} where M2 where M1 where S<:AbstractArray{T, 1} where T<:Real}, sparams=svec(2), method=kwerr(Any, Vararg{Any, N}) where {N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000009d0, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Union{RipQP.RipQPMonoSolver{T, _A, Int64, _B, _C, Float64, _D, _E} where _E<:(RipQP.PreallocatedFloatData{T, _A, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T, _A} where Dda<:RipQP.DescentDirectionAllocs{T, _A} where Res<:RipQP.AbstractResiduals{T, _A}) where _D<:(RipQP.Abstract_QM_FloatData{T, _A, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where _C<:RipQP.ScaleData{T, _A} where _B<:QuadraticModels.AbstractQuadraticModel{T, _A} where _A, RipQP.RipQPMonoSolver{T, S, Int64, _B, _C, Float64, _D, _E} where _E<:(RipQP.PreallocatedFloatData{T, S, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T, S} where Dda<:RipQP.DescentDirectionAllocs{T, S} where Res<:RipQP.AbstractResiduals{T, S}) where _D<:(RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where _C<:RipQP.ScaleData{T, S} where _B<:QuadraticModels.AbstractQuadraticModel{T, S} where S} where T<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228cf31560)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Union{RipQP.RipQPMonoSolver{T, _A, Int64, _B, _C, Float64, _D, _E} where _E<:(RipQP.PreallocatedFloatData{T, _A, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T, _A} where Dda<:RipQP.DescentDirectionAllocs{T, _A} where Res<:RipQP.AbstractResiduals{T, _A}) where _D<:(RipQP.Abstract_QM_FloatData{T, _A, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where _C<:RipQP.ScaleData{T, _A} where _B<:QuadraticModels.AbstractQuadraticModel{T, _A} where _A, RipQP.RipQPMonoSolver{T, S, Int64, _B, _C, Float64, _D, _E} where _E<:(RipQP.PreallocatedFloatData{T, S, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T, S} where Dda<:RipQP.DescentDirectionAllocs{T, S} where Res<:RipQP.AbstractResiduals{T, S}) where _D<:(RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where _C<:RipQP.ScaleData{T, S} where _B<:QuadraticModels.AbstractQuadraticModel{T, S} where S} where T<:Real, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.iszero)}, var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool, Bool}, Tuple{Int64, Int64}} where T<:(Array{_A, 2} where _A)}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742286a95aa0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.iszero)}, var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool, Bool}, Tuple{Int64, Int64}} where T<:(Array{_A, 2} where _A)}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, sparams=svec(), method=_axes(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047da, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.:(/)), FillArrays.Zeros{Float64, 1, Tuple{Base.OneTo{Int64}}}, Array{T, 1} where T<:Number}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(6, 0x742282ed91a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.:(/)), FillArrays.Zeros{Float64, 1, Tuple{Base.OneTo{Int64}}}, Array{T, 1} where T<:Number}, sparams=svec(), method=broadcasted(Base.Broadcast.DefaultArrayStyle{N} where N, typeof(Base.:(/)), FillArrays.AbstractZeros{T, N, Axes} where Axes where N where T, AbstractArray{var"#s9", N} where N where var"#s9"<:Number), fully_covers=true), #, #, #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009681, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T}, SolverTest.var"#f#98", Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74227156b200)[Core.MethodMatch(spec_types=Tuple{Type{ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T}, SolverTest.var"#f#98", Any}, sparams=svec(S), method=(::Type{ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T})(Any, S) where {S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096b3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), Any, Any, Any, Base.RefValue{T} where T, AbstractArray{T, N} where N where T, Float64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74228331b360)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Base.Broadcast.BroadcastStyle, F, Any, Base.RefValue{T} where T, AbstractArray{T, N} where N where T, Float64} where F, sparams=svec(F<:F), method=broadcasted(Base.Broadcast.BroadcastStyle, F, Any...) where {F}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Any, Any, Any, Base.RefValue{T} where T, AbstractArray{T, N} where N where T, Float64}, sparams=svec(F), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000495a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._xfadjoint_unwrap), Base.Generator{I, Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}} where I<:(Base.Generator{Array{Int64, 1}, F} where F<:(NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLPModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T))}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422861b4c00)[Core.MethodMatch(spec_types=Tuple{typeof(Base._xfadjoint_unwrap), Base.Generator{I, Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}} where I<:(Base.Generator{Array{Int64, 1}, F} where F<:(NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLPModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T))}, sparams=svec(), method=_xfadjoint_unwrap(Base.Generator{I, F} where F where I), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000031fa, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseArrays.sparse), Array{T, 2} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742284833800)[Core.MethodMatch(spec_types=Tuple{typeof(SparseArrays.sparse), Array{T, 2} where T<:Real}, sparams=svec(T<:Real), method=sparse(AbstractArray{Tv, 2}) where {Tv}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009675, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.push_history_residuals!), RipQP.AbstractResiduals{T, S} where S where T<:Real, RipQP.IterData{T, S} where S where T<:Real, RipQP.PreallocatedDataK2Krylov{T, S, M, MT, Pr, Ksol} where Ksol<:(Krylov.KrylovWorkspace{T, FC, S} where S where FC where T) where Pr<:(RipQP.PreconditionerData{T, S} where S where T<:Real) where MT<:Union{Int64, RipQP.MatrixTools{T}} where M<:Union{AbstractArray{T, 2}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where S where T<:Real, RipQP.QM_IntData}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a6e1c1e0)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.push_history_residuals!), RipQP.ResidualsHistory{T, S} where S, RipQP.IterData{T, S} where S, RipQP.PreallocatedDataK2Krylov{T, S, M, MT, Pr, Ksol} where Ksol<:(Krylov.KrylovWorkspace{T, FC, S} where S where FC where T) where Pr<:(RipQP.PreconditionerData{T, S} where S where T<:Real) where MT<:Union{Int64, RipQP.MatrixTools{T}} where M<:Union{AbstractArray{T, 2}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where S, RipQP.QM_IntData} where T<:Real, sparams=svec(T<:Real), method=push_history_residuals!(RipQP.ResidualsHistory{T, S} where S, RipQP.IterData{T, S} where S, RipQP.PreallocatedData{T, S} where S, RipQP.QM_IntData) where {T<:Real}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Base.RefValue{ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{Nothing}}, Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}} where var"#s175"<:Tuple{Base.RefValue{ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{Nothing}}, Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}}, Base.Val{3}}, limit=5), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742282fa6860)[Core.MethodMatch(spec_types=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Base.RefValue{ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{Nothing}}, Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}} where var"#s175"<:Tuple{Base.RefValue{ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{Nothing}}, Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}}, Base.Val{3}}, sparams=svec(), method=ntuple(Any, Base.Val{3}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000017dc, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), var"#s179"} where var"#s179"<:Tuple{Type}, Type{LinearOperators.LinearOperator{_A, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where _A, Any, Any, Bool, Any, LinearOperators.var"#opDiagonal##0#opDiagonal##1"{var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T, LinearOperators.var"#opDiagonal##0#opDiagonal##1"{var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T, LinearOperators.var"#opDiagonal##2#opDiagonal##3"{typeof(Base.conj), var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d4a8c00)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), var"#s179"} where var"#s179"<:Tuple{Type}, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, I, I, Bool, Bool, LinearOperators.var"#opDiagonal##0#opDiagonal##1"{var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T, LinearOperators.var"#opDiagonal##0#opDiagonal##1"{var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T, LinearOperators.var"#opDiagonal##2#opDiagonal##3"{typeof(Base.conj), var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T} where I<:Integer where T, sparams=svec(T, I<:I<:Integer), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, I, I, Bool, Bool, Any, Any, Any) where {T, I<:Integer}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), SolverCore.GenericExecutionStats{T, V, V, Tsp} where Tsp where V where V<:AbstractArray{T, 1} where T, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a9c8e940)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), SolverCore.GenericExecutionStats{T, V, V, Tsp} where Tsp where V where V<:AbstractArray{T, 1} where T, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.zero), Type{T} where Float64<:T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422866b9ec0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.zero), Type{T} where Float64<:T<:Real}, sparams=svec(Float64<:T<:Real), 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.dataids), Array{Ti, 1} where Ti<:Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422849a1520)[Core.MethodMatch(spec_types=Tuple{typeof(Base.dataids), Array{Ti, 1} where Ti<:Integer}, sparams=svec(), method=dataids(Array{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001321, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Generator{I, F} where F where I}, Base.var"#ntuple##0#ntuple##1"{Base.Returns{Bool}}, Base.UnitRange{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a79be540)[Core.MethodMatch(spec_types=Tuple{Type{Base.Generator{I, F} where F where I}, Base.var"#ntuple##0#ntuple##1"{Base.Returns{Bool}}, Base.UnitRange{Int64}}, sparams=svec(Base.UnitRange{Int64}, Base.var"#ntuple##0#ntuple##1"{Base.Returns{Bool}}), method=(::Type{Base.Generator{I, F} where F where I})(F, I) where {I, F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000420, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eachindex), Base.IndexLinear, Base.SubArray{_A, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{_A, 1} where _A) where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7422886223a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), Base.IndexLinear, Base.SubArray{_A, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{_A, 1} where _A) where _A}, sparams=svec(), method=eachindex(Base.IndexLinear, AbstractArray{T, 1} where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001257, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.rm_singleton_indices), Tuple{Vararg{Bool}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422865a2e00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.rm_singleton_indices), Tuple{Vararg{Bool}}}, sparams=svec(), method=rm_singleton_indices(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002dd1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.IteratorsMD._splitrest), Tuple{}, Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x742284dcb0a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.IteratorsMD._splitrest), Tuple{}, Tuple{}}, sparams=svec(), method=_splitrest(Tuple{}, Tuple{}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.IteratorsMD._splitrest), Tuple{}, Tuple}, sparams=svec(), method=_splitrest(Tuple{}, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004622, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.compute_μ), AbstractArray{Float64, 1}, AbstractArray{Float64, 1}, AbstractArray{Float64, 1}, AbstractArray{Float64, 1}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a8f7c680)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.compute_μ), AbstractArray{Float64, 1}, AbstractArray{Float64, 1}, AbstractArray{Float64, 1}, AbstractArray{Float64, 1}, Int64, Int64}, sparams=svec(), method=compute_μ(Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), Base.SubArray{_A, 1, P, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, false} where P<:(Array{Tv, 1} where Tv) where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d6cb420)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), Base.SubArray{_A, 1, P, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, false} where P<:(Array{Tv, 1} where Tv) where _A}, sparams=svec(), method=combine_styles(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004830, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#_growend!##0#_growend!##1"{Array{QuadraticModels.PresolveOperation{T, S}, 1}, Int64, Int64, Int64, Int64, Int64, Memory{QuadraticModels.PresolveOperation{T, S}}, GenericMemoryRef{:not_atomic, QuadraticModels.PresolveOperation{T, S}, Core.AddrSpace{Core}(0x00)}} where T<:Real where S where T<:Real where S where T<:Real where S}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228bffcee0)[Core.MethodMatch(spec_types=Tuple{Base.var"#_growend!##0#_growend!##1"{Array{QuadraticModels.PresolveOperation{T, S}, 1}, Int64, Int64, Int64, Int64, Int64, Memory{QuadraticModels.PresolveOperation{T, S}}, GenericMemoryRef{:not_atomic, QuadraticModels.PresolveOperation{T, S}, Core.AddrSpace{Core}(0x00)}} where T<:Real where S where T<:Real where S where T<:Real where S}, sparams=svec(), method=(::Base.var"#_growend!##0#_growend!##1"{a, newmemlen, offset, newlen, len, memlen, mem, ref})(), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000112e, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.LogicalIndex{Int64, A} where A<:(AbstractArray{Bool, N} where N)}, Base.BitArray{N} where N}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742287a6fd60)[Core.MethodMatch(spec_types=Tuple{Type{Base.LogicalIndex{Int64, A} where A<:(AbstractArray{Bool, N} where N)}, Base.BitArray{N} where N}, sparams=svec(), method=(::Type{Base.LogicalIndex{Int64, A} where A<:(AbstractArray{Bool, N} where N)})(AbstractArray{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004692, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.ndims), Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.iszero)}, var"#s179"}} where var"#s179"<:Tuple{Array{T, 2} where T}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742285b96e00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.ndims), Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.iszero)}, var"#s179"}} where var"#s179"<:Tuple{Array{T, 2} where T}}, sparams=svec(2), method=ndims(Type{var"#s677"} where var"#s677"<:(Base.Broadcast.Broadcasted{var"#s676", var"#s675", F, Args} where Args<:Tuple where F where var"#s675"<:Tuple{Vararg{Any, N}} where var"#s676")) where {N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047ee, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseArrays.nonzeros), SparseArrays.SparseMatrixCSC{Tv, Ti} where Ti<:Integer where Tv}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742284002de0)[Core.MethodMatch(spec_types=Tuple{typeof(SparseArrays.nonzeros), SparseArrays.SparseMatrixCSC{Tv, Ti} where Ti<:Integer where Tv}, sparams=svec(), method=nonzeros(Union{SparseArrays.FixedSparseCSC{Tv, Ti} where Ti<:Integer where Tv, SparseArrays.SparseMatrixCSC{Tv, Ti} where Ti<:Integer where Tv}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009675, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{AbstractArray{T, 1} where T<:Real, Float64} where var"#s175"<:Tuple{AbstractArray{T, 1} where T<:Real, Float64}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742287af9300)[Core.MethodMatch(spec_types=Tuple{Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{AbstractArray{T, 1} where T<:Real, Float64} where var"#s175"<:Tuple{AbstractArray{T, 1} where T<:Real, Float64}, Int64}, sparams=svec(var"#s175"<:Tuple{AbstractArray{T, 1} where T<:Real, Float64}), method=(::Base.var"#cvt1#convert##0"{T, x})(Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000376, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseArrays.LibSuiteSparse.cholmod_l_change_factor), Int64, Bool, Bool, Bool, Bool, SparseArrays.CHOLMOD.Factor{Tv, Int64} where Tv<:Union{Float32, Float64}, Ref{SparseArrays.LibSuiteSparse.cholmod_common_struct}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228a1c1060)[Core.MethodMatch(spec_types=Tuple{typeof(SparseArrays.LibSuiteSparse.cholmod_l_change_factor), Int64, Bool, Bool, Bool, Bool, SparseArrays.CHOLMOD.Factor{Tv, Int64} where Tv<:Union{Float32, Float64}, Ref{SparseArrays.LibSuiteSparse.cholmod_common_struct}}, sparams=svec(), method=cholmod_l_change_factor(Any, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009675, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.coo_prod!), Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 1}, AbstractArray{T, 1} where T, Base.SubArray{Float64, 1, Array{Float64, 1}, Tuple{Array{Int64, 1}}, false}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228871bb00)[Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.coo_prod!), Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 1}, AbstractArray{T, 1} where T, Base.SubArray{Float64, 1, Array{Float64, 1}, Tuple{Array{Int64, 1}}, false}}, sparams=svec(), method=coo_prod!(AbstractArray{var"#s6", 1} where var"#s6"<:Integer, AbstractArray{var"#s5", 1} where var"#s5"<:Integer, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096b0, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.pairs), NamedTuple{names, T} where T<:Tuple where names}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422aab708c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.pairs), NamedTuple{names, T} where T<:Tuple where names}, sparams=svec(), method=pairs(NamedTuple{names, T} where T<:Tuple where names), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001888, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{RipQP.QM_FloatData_ref{Float64, S, M1, M2} where M2 where M1 where S, RipQP.Point{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T<:Real where T<:Real}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742284243600)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{RipQP.QM_FloatData_ref{Float64, S, M1, M2} where M2 where M1 where S, RipQP.Point{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T<:Real where T<:Real}, Int64, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000689, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eltype), SparseArrays.CHOLMOD.Dense{Tv} where Tv<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a7f4a100)[Core.MethodMatch(spec_types=Tuple{typeof(Base.eltype), SparseArrays.CHOLMOD.Dense{Tv} where Tv<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}}, sparams=svec(), method=eltype(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001246, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4711", 2} where var"#s4711"<:T) where T, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{NLPModels.var"##hess_op!#25", Any, typeof(NLPModels.hess_op!), ADNLPModels.ADNLPModel{T, S, Si} where Si where S<:AbstractArray{T, 1} where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d668c60)[Core.MethodMatch(spec_types=Tuple{NLPModels.var"##hess_op!#25", Real, typeof(NLPModels.hess_op!), ADNLPModels.ADNLPModel{T, S, Si} where Si, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T} where S<:AbstractArray{T, 1} where T, sparams=svec(T, S<:AbstractArray{T, 1}), method=var"#hess_op!#25"(Real, typeof(NLPModels.hess_op!), NLPModels.AbstractNLPModel{T, S}, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T) where {T, S}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096b0, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s179"} where var"#s179"<:AbstractArray{Float64, 1}, AbstractArray{Float64, 1}}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{LinearOperators.var"#143#144", Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d6ff040)[Core.MethodMatch(spec_types=Tuple{LinearOperators.var"#143#144", Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T}, sparams=svec(), method=var"#143"(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Fix{2, F, T} where T where F}, typeof(Base.:(var"==")), Base.OneTo{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a7c50b00)[Core.MethodMatch(spec_types=Tuple{Type{Base.Fix{2, F, T} where T where F}, typeof(Base.:(var"==")), Base.OneTo{Int64}}, sparams=svec(2, typeof(Base.:(var"=="))), method=(::Type{Base.Fix{N, F, T} where T where F})(F, Any) where {N, F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c46, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eachindex), Base.IndexLinear, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{FillArrays.Fill{Float64, 1, Tuple{Base.OneTo{Int64}}}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Number)}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d0e5d40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), Base.IndexLinear, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{FillArrays.Fill{Float64, 1, Tuple{Base.OneTo{Int64}}}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Number)}}, sparams=svec(), method=eachindex(Base.IndexStyle, Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047e4, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:ρ0, :δ0), var"#s179"} where var"#s179"<:Tuple{Any, Any}, Type{RipQP.K2LDLParams{_A, Fact} where Fact} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228f0ec7c0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:ρ0, :δ0), var"#s179"} where var"#s179"<:Tuple{Any, Any}, Type{RipQP.K2LDLParams{_A, Fact} where Fact} where _A}, sparams=svec(_A), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, Type{RipQP.K2LDLParams{T, Fact} where Fact}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.get), Base.IdDict{Any, Any}, QuadraticModels.AbstractQuadraticModel{Float64, S} where S, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a9703e20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.get), Base.IdDict{Any, Any}, QuadraticModels.AbstractQuadraticModel{Float64, S} where S, Symbol}, sparams=svec(Any, Any), method=get(Base.IdDict{K, V}, Any, Any) where {K, V}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000017a3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Dict{_A, _B}} where _B where _A, Tuple{Pair{Symbol, QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2}} where M2 where M1 where S where T, Pair{Symbol, Array{QuadraticModels.PresolveOperation{T, _A}, 1}} where _A where T<:Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226dbb6a20)[Core.MethodMatch(spec_types=Tuple{Type{Base.Dict{_A, _B}} where _B where _A, Tuple{Pair{Symbol, QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2}} where M2 where M1 where S where T, Pair{Symbol, Array{QuadraticModels.PresolveOperation{T, _A}, 1}} where _A where T<:Real}}, sparams=svec(_A, _B), method=(::Type{Base.Dict{K, V}})(Any) where {K, V}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000034b1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{SparseArrays.SparseMatrixCSC{Tv, Ti} where Ti<:Integer where Tv}, Int64, Int64, Array{Int64, 1}, Array{Int64, 1}, Array{_A, 1} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a9f61660)[Core.MethodMatch(spec_types=Tuple{Type{SparseArrays.SparseMatrixCSC{Tv, Ti} where Ti<:Integer where Tv}, Int64, Int64, Array{Int64, 1}, Array{Int64, 1}, Array{_A, 1} where _A}, sparams=svec(), method=(::Type{SparseArrays.SparseMatrixCSC{Tv, Ti} where Ti<:Integer where Tv})(Integer, Integer, Array{T, 1} where T, Array{T, 1} where T, Array{T, 1} where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009675, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Type{Array{Float64, 1}}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7422a6dac820)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Type{Array{Float64, 1}}, Tuple{Base.OneTo{Int64}}}, sparams=svec(Array{Float64, 1}), method=similar(Type{T}, Tuple{Union{Integer, Base.OneTo{T} where T<:Integer}, Vararg{Union{Integer, Base.OneTo{T} where T<:Integer}}}) where {T<:(AbstractArray{T, N} where N where T)}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000129c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcast_unalias), Array{Tv, 1} where Tv, Array{_A, 1} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a94c6fc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcast_unalias), Array{Tv, 1} where Tv, Array{_A, 1} where _A}, sparams=svec(), method=broadcast_unalias(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048c7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.preprocess_args), SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv<:Real, Tuple{Array{R, 1} where R<:Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228dc342c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.preprocess_args), SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv<:Real, Tuple{Array{R, 1} where R<:Real}}, sparams=svec(), method=preprocess_args(Any, Tuple{Any}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048ce, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.merge!), Any, Base.AbstractDict{K, V} where V where K}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{Type{LinearAlgebra.Adjoint{T, S} where S where T}, AbstractArray{Float64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a6f8e3e0)[Core.MethodMatch(spec_types=Tuple{Type{LinearAlgebra.Adjoint{T, S} where S where T}, AbstractArray{Float64, 1}}, sparams=svec(), method=(::Type{LinearAlgebra.Adjoint{T, S} where S where T})(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000007ac8, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(var"==")), Type{T} where T<:Real, Type{Tlow} where Tlow<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742271193fa0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.:(var"==")), Type{T} where T<:Real, Type{Tlow} where Tlow<:Real}, sparams=svec(), method=var"=="(Type, Type), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000bcd, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isbits), Array{T, 1} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422aa36cc80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.isbits), Array{T, 1} where T<:Real}, sparams=svec(), method=isbits(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000505, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.abs), Array{R, 1} where R<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226edd6520)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.abs), Array{R, 1} where R<:Real}, sparams=svec(typeof(Base.abs)), method=broadcasted(Base.Broadcast.BroadcastStyle, F, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000495a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(StaticArrays.has_size), Type{StaticArraysCore.SArray{Tuple{2}, _A, N, L} where L where N} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x742285539ee0)[ Core.MethodMatch(spec_types=Tuple{typeof(StaticArrays.has_size), Type{StaticArraysCore.SArray{Tuple{2}, _A, N, L} where L where N} where _A}, sparams=svec(Tuple{2}), method=has_size(Type{var"#s25"} where var"#s25"<:(StaticArraysCore.StaticArray{S, T, N} where N where T)) where {S<:Tuple}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000969d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core._typeof_captured_variable), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real)}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228b257b80)[Core.MethodMatch(spec_types=Tuple{typeof(Core._typeof_captured_variable), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real)}}, sparams=svec(), method=_typeof_captured_variable(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000004a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.kwerr), NamedTuple{names, T} where T<:Tuple where names, Type{SolverTools.TRONTrustRegion{T, V} where V where T}, Any, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228cd35480)[Core.MethodMatch(spec_types=Tuple{typeof(Base.kwerr), NamedTuple{names, T} where T<:Tuple where names, Type{SolverTools.TRONTrustRegion{T, V} where V where T}, Any, Any}, sparams=svec(3), method=kwerr(Any, Vararg{Any, N}) where {N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000009d0, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.RefValue{T} where T}, typeof(Base.min)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a7bea900)[Core.MethodMatch(spec_types=Tuple{Type{Base.RefValue{T} where T}, typeof(Base.min)}, sparams=svec(typeof(Base.min)), 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.throw_boundserror), Array{QuadraticModels.Col{T}, 1} where T<:Real, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228cc5f900)[Core.MethodMatch(spec_types=Tuple{typeof(Base.throw_boundserror), Array{QuadraticModels.Col{T}, 1} where T<:Real, Tuple{Int64}}, sparams=svec(), method=throw_boundserror(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000310, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.map), typeof(Base.unchecked_oneto), Tuple{Vararg{Int64, N}} where N}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{AbstractArray{Float64, 1}, Float64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d530120)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{AbstractArray{Float64, 1}, Float64}}}, sparams=svec(), method=(::Type{MethodError})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000009d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.show), Base.IOContext{Base.GenericIOBuffer{Memory{UInt8}}}, FixedPointNumbers.Fixed{T, f} where f where T<:Signed}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742285d998c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.show), Base.IOContext{Base.GenericIOBuffer{Memory{UInt8}}}, FixedPointNumbers.Fixed{T, f} where f where T<:Signed}, sparams=svec(T<:Signed, f), method=show(IO, FixedPointNumbers.FixedPoint{T, f}) where {T, f}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000972d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, T}} where T where F<:(RipQP.var"#PreconditionerData##6#PreconditionerData##7"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real) where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##6#PreconditionerData##7"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real, Nothing, Nothing, Int64, Int64, Int64, Bool, Bool, Any, Any, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742271532740)[Core.MethodMatch(spec_types=Tuple{Type{LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, T}} where T where F<:(RipQP.var"#PreconditionerData##6#PreconditionerData##7"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real) where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##6#PreconditionerData##7"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real, Nothing, Nothing, Int64, Int64, Int64, Bool, Bool, Any, Any, Bool}, sparams=svec(), method=(::Type{LinearOperators.LinearOperator{T, I<:Integer, F, Ft, Fct, S}})(Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Array{Int64, 1}}, Array{Int64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a7beb840)[Core.MethodMatch(spec_types=Tuple{Type{Array{Int64, 1}}, Array{Int64, 1}}, sparams=svec(Int64, 1, Int64), method=(::Type{Array{T, N}})(AbstractArray{S, N}) where {T, N, S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010df, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:(RipQP.var"#PreconditionerData##6#PreconditionerData##7"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real), RipQP.var"#PreconditionerData##6#PreconditionerData##7"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226ee3a860)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, RipQP.var"#PreconditionerData##6#PreconditionerData##7"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, RipQP.var"#PreconditionerData##6#PreconditionerData##7"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real} where T<:(RipQP.var"#PreconditionerData##6#PreconditionerData##7"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real), sparams=svec(T), method=convert(Type{T}, T) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000034c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.eltypes), Tuple{FillArrays.AbstractZeros{T, 1, Axes} where Axes where T, Array{T, 1} where T<:Number}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742271974860)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.eltypes), Tuple{FillArrays.AbstractZeros{T, 1, Axes} where Axes where T, Array{T, 1} where T<:Number}}, sparams=svec(), method=eltypes(Tuple{Any, Any}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048ab, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.RefValue{typeof(SparseMatricesCOO.replace_if_minusinf)}, Array{T, N} where N where T, Any}}, UInt64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422865db560)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.RefValue{typeof(SparseMatricesCOO.replace_if_minusinf)}, Array{T, N} where N where T, Any}}, UInt64}, sparams=svec(), method=(::Type{MethodError})(Any, Any, UInt64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000009c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), Array{T, 1} where T, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226f2ec720)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Array{T, 1} where T, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"}, sparams=svec(), method=materialize!(Any, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Array{T, 1} where T, Any}, sparams=svec(), method=materialize!(Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048be, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{SparseArrays.CHOLMOD.var"##symbolic#7", Nothing, Bool, Bool, Bool, typeof(SparseArrays.CHOLMOD.symbolic), SparseArrays.CHOLMOD.Sparse{Tv, Int64} where Tv<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228b0e6fa0)[Core.MethodMatch(spec_types=Tuple{SparseArrays.CHOLMOD.var"##symbolic#7", Nothing, Bool, Bool, Bool, typeof(SparseArrays.CHOLMOD.symbolic), SparseArrays.CHOLMOD.Sparse{Tv, Int64} where Tv<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}}, sparams=svec(Int64), method=var"#symbolic#7"(Union{Nothing, AbstractArray{var"#s419", 1} where var"#s419"<:Integer}, Bool, Bool, Bool, typeof(SparseArrays.CHOLMOD.symbolic), SparseArrays.CHOLMOD.Sparse{var"#s418", Ti} where var"#s418"<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}) where {Ti}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009675, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228f5d5200)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T<:Real}, sparams=svec(), method=size(LinearOperators.AbstractLinearOperator{T} where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_type), Type{Ti} where Ti<:Integer, Type{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7422a8ce4560)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_type), Type{Union{}}, Type{Int64}}, sparams=svec(Int64), method=promote_type(Type{Union{}}, Type{T}) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_type), Type{Int64}, Type{Int64}}, sparams=svec(Int64), method=promote_type(Type{T}, Type{T}) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_type), Type{Ti} where Ti<:Integer, Type{Int64}}, sparams=svec(Ti<:Integer, Int64), 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(NLPModels.jac_nln_coord!), ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422858998c0)[Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_nln_coord!), ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T}, sparams=svec(), method=jac_nln_coord!(Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096b3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Core.kwcall), Tuple{NamedTuple{names, T} where T<:Tuple where names, Type, QuadraticModels.QuadraticModel{T, S, M1, M2} where M2 where M1 where S<:AbstractArray{T, 1} where T<:Real}, UInt64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d410c00)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Core.kwcall), Tuple{NamedTuple{names, T} where T<:Tuple where names, Type, QuadraticModels.QuadraticModel{T, S, M1, M2} where M2 where M1 where S<:AbstractArray{T, 1} where T<:Real}, UInt64}, sparams=svec(), method=(::Type{MethodError})(Any, Any, UInt64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000009c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.diff_names), Tuple{}, Tuple{Vararg{Symbol}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228bb47ee0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.diff_names), Tuple{}, Tuple{Vararg{Symbol}}}, sparams=svec(), method=diff_names(Tuple{Vararg{Symbol}}, Tuple{Vararg{Symbol}}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001aaf, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:memory,), Tuple{Int64}}, Type{Krylov.GmresWorkspace{T, FC, S} where S where FC where T}, Vararg{Any, 4}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742288a07280)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:memory,), Tuple{Int64}}, Type{Krylov.GmresWorkspace{T, FC, S} where S where FC where T}, LLSModels.LLSModel{T, S, M1, M2} where M2 where M1 where S where T, Any, Any, Any}, sparams=svec(), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, Type{Krylov.GmresWorkspace{T, FC, S} where S where FC where T}, LLSModels.LLSModel{T, S, M1, M2} where M2 where M1 where S where T, Any...), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976b, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core._typeof_captured_variable), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(FillArrays.Zeros{_A, 1, Tuple{Base.OneTo{Int64}}} where _A)}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422715451c0)[Core.MethodMatch(spec_types=Tuple{typeof(Core._typeof_captured_variable), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(FillArrays.Zeros{_A, 1, Tuple{Base.OneTo{Int64}}} where _A)}}, sparams=svec(), method=_typeof_captured_variable(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000004a, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{RipQP.PreconditionerData{T, S} where S where T<:Real}, RipQP.K2KrylovParams{T, PT, FT} where FT<:typeof(DataType) where PT where T, Any, Int64, Int64, RipQP.Regularization{T} where T<:Real, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226c95f940)[Core.MethodMatch(spec_types=Tuple{Type{RipQP.PreconditionerData{T, S} where S where T<:Real}, RipQP.K2KrylovParams{T, PT, FT} where FT<:typeof(DataType) where PT<:(RipQP.LDL{FloatType, F} where F<:RipQP.AbstractFactorization where FloatType<:typeof(DataType)), RipQP.FactorizationData{Tlow}, Int64, Int64, RipQP.Regularization{Tlow}, Any} where Tlow<:Real where T, sparams=svec(T, Tlow<:Real), method=(::Type{RipQP.PreconditionerData{T, S} where S where T<:Real})(RipQP.AugmentedKrylovParams{T, var"#s44"} where var"#s44"<:(RipQP.LDL{FloatType, F} where F<:RipQP.AbstractFactorization where FloatType<:typeof(DataType)), RipQP.FactorizationData{Tlow}, Int64, Int64, RipQP.Regularization{Tlow}, Any) where {T, Tlow<:Real}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{QuadraticModels.SingletonRow{Float64, Array{Float64, 1}}}, Int64, Int64, Float64, Bool, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228c5a9280)[Core.MethodMatch(spec_types=Tuple{Type{QuadraticModels.SingletonRow{Float64, Array{Float64, 1}}}, Int64, Int64, Float64, Bool, Bool}, sparams=svec(), method=(::Type{QuadraticModels.SingletonRow{T, S}})(Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009745, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Tuple{Pair{Symbol, Nothing}, Vararg{Pair{A, B} where B where A}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742271bc0580)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Tuple{Pair{Symbol, Nothing}, Vararg{Pair{A, B} where B where A}}}, sparams=svec(), method=iterate(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000067a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), ReverseDiff.TrackedReal{V, D, O} where O<:(ReverseDiff.TrackedArray{V, D, 1, VA, DA} where V<:Real where D<:Real where VA<:(Array{T, 1} where T<:Real) where DA<:(Array{T, 1} where T<:Real)) where D<:Real where V<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a7a87160)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), ReverseDiff.TrackedReal{V, D, O} where O<:(ReverseDiff.TrackedArray{V, D, 1, VA, DA} where V<:Real where D<:Real where VA<:(Array{T, 1} where T<:Real) where DA<:(Array{T, 1} where T<:Real)) where D<:Real where V<:Real, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), FillArrays.Zeros{T, 1, Axes} where Axes where T<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228a7798c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), FillArrays.Zeros{T, 1, Axes} where Axes where T<:Real, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, Any, Tuple{Base.RefValue{typeof(Base.:(-))}, Array{Float64, 1}, AbstractArray{T, N} where N where T}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74228ade0520)[ Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, Tuple, Tuple{Base.RefValue{typeof(Base.:(-))}, Array{Float64, 1}, AbstractArray{T, N} where N where T}}, sparams=svec(), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, Tuple, Tuple), fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, Any, Tuple{Base.RefValue{typeof(Base.:(-))}, Array{Float64, 1}, AbstractArray{T, N} where N where T}}, sparams=svec(F), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple) where {F}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.jac_nln_structure!), NLPModels.AbstractNLPModel{T, S} where S where T, Array{Int64, 1}, Array{Int64, 1}}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.get_mat_QPData), Any, Any, Int64, Int64, RipQP.SolverParams{T} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7422722c81a0)[ Core.MethodMatch(spec_types=Tuple{typeof(RipQP.get_mat_QPData), SparseMatricesCOO.SparseMatrixCOO{T, Int64}, SparseMatricesCOO.SparseMatrixCOO{T, Int64}, Int64, Int64, RipQP.SolverParams{T} where T} where T, sparams=svec(T), method=get_mat_QPData(SparseMatricesCOO.SparseMatrixCOO{T, Int64}, SparseMatricesCOO.SparseMatrixCOO{T, Int64}, Int64, Int64, RipQP.SolverParams{T} where T) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(RipQP.get_mat_QPData), Any, Any, Int64, Int64, RipQP.SolverParams{T} where T}, sparams=svec(), method=get_mat_QPData(Any, Any, Int64, Int64, RipQP.SolverParams{T} where T), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.oneto), Tuple{Integer}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74228370da60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.oneto), Tuple{Integer}}, sparams=svec(typeof(Base.oneto)), method=broadcasted(F, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004958, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{NamedTuple{(:status, :solution, :objective, :primal_feas, :dual_feas, :multipliers, :multipliers_L, :multipliers_U, :iter, :elapsed_time, :solver_specific), T} where T<:Tuple}, Tuple{Symbol, Array{Float64, 1}, Float64, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Float64, Union{Base.Dict{Symbol, Union{Nothing, Array{QuadraticModels.PresolveOperation{Float64, Array{Float64, 1}}, 1}}}, Base.Dict{Symbol, Nothing}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d982f00)[Core.MethodMatch(spec_types=Tuple{Type{NamedTuple{(:status, :solution, :objective, :primal_feas, :dual_feas, :multipliers, :multipliers_L, :multipliers_U, :iter, :elapsed_time, :solver_specific), T} where T<:Tuple}, Tuple{Symbol, Array{Float64, 1}, Float64, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Float64, Union{Base.Dict{Symbol, Union{Nothing, Array{QuadraticModels.PresolveOperation{Float64, Array{Float64, 1}}, 1}}}, Base.Dict{Symbol, Nothing}}}}, sparams=svec((:status, :solution, :objective, :primal_feas, :dual_feas, :multipliers, :multipliers_L, :multipliers_U, :iter, :elapsed_time, :solver_specific)), 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(FixedPointNumbers.throw_converterror), Type{F} where F<:FixedPointNumbers.Fixed{T, f} where f where T<:Signed, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742285e0df00)[Core.MethodMatch(spec_types=Tuple{typeof(FixedPointNumbers.throw_converterror), Type{F} where F<:FixedPointNumbers.Fixed{T, f} where f where T<:Signed, Int64}, sparams=svec(F<:FixedPointNumbers.Fixed{T<:Signed, f}), method=throw_converterror(Type{X}, Any) where {X<:(FixedPointNumbers.FixedPoint{T, f} where f where T<:Integer)}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000972d, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.real), var"#s179"} where var"#s179"<:Tuple{Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64}}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228bccbc00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.real), var"#s179"} where var"#s179"<:Tuple{Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64}}, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.copyto_nonleaf!), Array{_A, 1} where _A, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(<=)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Base.OneTo{Int64}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a90b0bc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.copyto_nonleaf!), Array{_A, 1} where _A, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(<=)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Base.OneTo{Int64}, Int64, Int64}, sparams=svec(), method=copyto_nonleaf!(Any, Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048f1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(var"==")), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R, Array{R, 1} where R}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d5a94c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(var"==")), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R, Array{R, 1} where R}, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.diff_types), NamedTuple{(:atol, :rtol), var"#s179"} where var"#s179"<:Tuple{Any, Any}, Tuple{Vararg{Symbol}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228ac41c40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.diff_types), NamedTuple{(:atol, :rtol), var"#s179"} where var"#s179"<:Tuple{Any, Any}, Tuple{Vararg{Symbol}}}, sparams=svec(), method=diff_types(NamedTuple{names, T} where T<:Tuple where names, Tuple{Vararg{Symbol}}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001ab1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(*)), Float64, Base.SubArray{T, N, P, I, L} where L where I where P where N where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7422a6d96720)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(*)), Float64, Base.SubArray{T, N, P, I, L} where L where I where P where N where T}, sparams=svec(typeof(Base.:(*))), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004959, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.tail), Tuple{Union{Integer, Base.IteratorsMD.CartesianIndex{N} where N, StaticArraysCore.StaticArray{var"#s25", Int64, N} where N where var"#s25"<:Tuple}, Base.IteratorsMD.CartesianIndex{0}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e4940e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.tail), Tuple{Union{Integer, Base.IteratorsMD.CartesianIndex{N} where N, StaticArraysCore.StaticArray{var"#s25", Int64, N} where N where var"#s25"<:Tuple}, Base.IteratorsMD.CartesianIndex{0}}}, sparams=svec(), method=tail(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000035d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eltype), Type{Base.LogicalIndex{Int64, Base.BitArray{N}}} where N}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7422854bf360)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.eltype), Type{Base.LogicalIndex{Int64, Base.BitArray{N}}} where N}, sparams=svec(Int64), method=eltype(Type{var"#s179"} where var"#s179"<:(AbstractArray{E, N} where N)) where {E}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001247, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.sum), Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote), Integer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226e490760)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.promote), Int64, Int64}, sparams=svec(Int64), method=promote(T, T, T...) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.promote), Integer, Int64}, sparams=svec(), method=promote(Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000617, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unsafe_convert), Type{Ptr{Nothing}}, Ptr{Int32}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742272c446e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_convert), Type{Ptr{Nothing}}, Ptr{Int32}}, sparams=svec(Ptr{Nothing}), 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{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:Union{Float32, Float64}, Float32}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(6, 0x7422a95d7e50)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Float32}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, Float32} where Float32<:T<:Union{Float32, Float64}, sparams=svec(Float32<:T<:Union{Float32, Float64}), method=convert(Type{T}, T) where {T<:Number}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:Union{Float32, Float64}, Float32}, sparams=svec(var"#s175"<:Union{Float32, Float64}), 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{Type{Memory{Nothing}}, UndefInitializer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422836cb5e0)[Core.MethodMatch(spec_types=Tuple{Type{Memory{Nothing}}, UndefInitializer, Int64}, sparams=svec(Nothing, 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(Base._methods), RipQP.var"#PreconditionerData##4#PreconditionerData##5"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Int64, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Tf<:Real) where Tlow<:Real, Type{Tuple}, Int64, UInt64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422aa4a8600)[Core.MethodMatch(spec_types=Tuple{typeof(Base._methods), RipQP.var"#PreconditionerData##4#PreconditionerData##5"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Int64, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Tf<:Real) where Tlow<:Real, Type{Tuple}, Int64, UInt64}, sparams=svec(), method=_methods(Any, Any, Int64, UInt64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000583, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), RipQP.ScaleDataLP{T, S} where S where Float64<:T<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228776bf40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), RipQP.ScaleDataLP{T, S} where S where Float64<:T<:Real, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Base.RefValue{typeof(Base.:(*))}, Any, Array{T, N} where N where T} where var"#s175"<:Tuple{Base.RefValue{typeof(Base.:(*))}, Any, Array{T, N} where N where T}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e2b9d40)[Core.MethodMatch(spec_types=Tuple{Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Base.RefValue{typeof(Base.:(*))}, Any, Array{T, N} where N where T} where var"#s175"<:Tuple{Base.RefValue{typeof(Base.:(*))}, Any, Array{T, N} where N where T}, Int64}, sparams=svec(var"#s175"<:Tuple{Base.RefValue{typeof(Base.:(*))}, Any, Array{T, N} where N where T}), method=(::Base.var"#cvt1#convert##0"{T, x})(Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000376, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Type{Bool}, Array{T, 1} where T<:Real, Vararg{Any}}, limit=3), nothing, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}}, UInt64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d463f00)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}}, UInt64}, sparams=svec(), method=(::Type{MethodError})(Any, Any, UInt64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000009c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(<)), Int64, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.ht_keyindex2_shorthash!), Base.Dict{K, Any} where K, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422aa13fe60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.ht_keyindex2_shorthash!), Base.Dict{K, Any} where K, Any}, sparams=svec(K, Any), method=ht_keyindex2_shorthash!(Base.Dict{K, V}, Any) where {K, V}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000034d3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{ft} where ft<:(AbstractArray{T, N} where N where T), Base.RefValue{typeof(Base.:(-))}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a9daa9c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Base.RefValue{typeof(Base.:(-))}}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000034c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Int64}, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a9232400)[Core.MethodMatch(spec_types=Tuple{Type{Int64}, Bool}, 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.getindex), Type{Float64}, Float64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422746bde80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Type{Float64}, Float64, Int64}, sparams=svec(Float64), 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(Base.convert), Type{var"#s175"} where var"#s175"<:(RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real), RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226e6f9b20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real} where T<:(RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real), sparams=svec(T), method=convert(Type{T}, T) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000034c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"##mapfoldl#270", Int64, typeof(Base.mapfoldl), Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}, typeof(Base.add_sum), Base.Generator{Array{Int64, 1}, F} where F<:(NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLPModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422861cc140)[Core.MethodMatch(spec_types=Tuple{Base.var"##mapfoldl#270", Int64, typeof(Base.mapfoldl), Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}, typeof(Base.add_sum), Base.Generator{Array{Int64, 1}, F} where F<:(NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLPModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T)}, sparams=svec(), method=var"#mapfoldl#270"(Any, typeof(Base.mapfoldl), Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000031ff, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Array{Int64, 1}}, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.RefValue{typeof(Base.identity)}}, typeof(Base.identity)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a9915300)[Core.MethodMatch(spec_types=Tuple{Type{Base.RefValue{typeof(Base.identity)}}, typeof(Base.identity)}, sparams=svec(typeof(Base.identity)), 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{Base.SubString{T} where T<:AbstractString}, AbstractString, Base.UnitRange{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742289a09b20)[Core.MethodMatch(spec_types=Tuple{Type{Base.SubString{T} where T<:AbstractString}, AbstractString, Base.UnitRange{Int64}}, sparams=svec(), method=(::Type{Base.SubString{T} where T<:AbstractString})(AbstractString, Base.AbstractUnitRange{var"#s215"} where var"#s215"<:Integer), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003763, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), Array{Tv, 1} where Tv<:Real, Any, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.sqrt), Tuple{Array{Float64, 1}}}}, typeof(Base.sqrt), Tuple{Array{Float64, 1}}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d24e040)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.sqrt), Tuple{Array{Float64, 1}}}}, typeof(Base.sqrt), Tuple{Array{Float64, 1}}, Tuple{Base.OneTo{Int64}}}, sparams=svec(Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.sqrt), Tuple{Array{Float64, 1}}), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args}})(Any, Any, Any) where {Style, Axes, F, Args}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.error_if_canonical_setindex), Base.IndexLinear, LinearAlgebra.Adjoint{Float64, Array{Float64, 1}}, Int64, Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e2ebbc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.error_if_canonical_setindex), Base.IndexLinear, LinearAlgebra.Adjoint{Float64, Array{Float64, 1}}, Int64, Integer}, sparams=svec(), method=error_if_canonical_setindex(Base.IndexStyle, AbstractArray{T, N} where N where T, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012fe, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._str_sizehint), Number}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d71b220)[Core.MethodMatch(spec_types=Tuple{typeof(Base._str_sizehint), Number}, sparams=svec(), method=_str_sizehint(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003dac, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{AbstractArray{Float64, 1}, AbstractArray{Float64, 1}} where var"#s175"<:Tuple{AbstractArray{Float64, 1}, AbstractArray{Float64, 1}}, Base.Val{2}}, limit=5), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422834a82a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{AbstractArray{Float64, 1}, AbstractArray{Float64, 1}} where var"#s175"<:Tuple{AbstractArray{Float64, 1}, AbstractArray{Float64, 1}}, Base.Val{2}}, sparams=svec(), method=ntuple(Any, Base.Val{2}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000017db, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseArrays.sparse_check_length), String, Array{Float64, 1}, Int64, Type{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742283ba8ac0)[Core.MethodMatch(spec_types=Tuple{typeof(SparseArrays.sparse_check_length), String, Array{Float64, 1}, Int64, Type{Int64}}, sparams=svec(), method=sparse_check_length(Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009675, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.Unknown, Nothing, typeof(Base.oneto), var"#s179"} where var"#s179"<:Tuple{Tuple{Vararg{Integer, N}} where N}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x742283786a60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.Unknown, Nothing, typeof(Base.oneto), var"#s179"} where var"#s179"<:Tuple{Tuple{Vararg{Integer, N}} where N}}, sparams=svec(), method=materialize(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048ba, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{SparseArrays.SparseMatrixCSC{Float64, Ti} where Ti<:Integer}, Array{Float64, 2}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422846c5060)[Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{SparseArrays.SparseMatrixCSC{Float64, Ti} where Ti<:Integer}, Array{Float64, 2}}, sparams=svec(), method=convert(Type{var"#s21"} where var"#s21"<:(SparseArrays.AbstractSparseMatrixCSC{Tv, Ti} where Ti<:Integer where Tv), AbstractArray{T, 2} where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009675, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), Base.var"#__cat_offset1!##2#__cat_offset1!##3"{Tuple{Bool}, Tuple{Int64}, Array{Ti, 1}} where Ti<:Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742284b4bc80)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), Base.var"#__cat_offset1!##2#__cat_offset1!##3"{Tuple{Bool}, Tuple{Int64}, Array{Ti, 1}} where Ti<:Integer}, sparams=svec(), method=Typeof(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000028, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), RipQP.FactorizationData{Tlow} where Tlow<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a976e6a0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), RipQP.FactorizationData{Tlow} where Tlow<:Real}, sparams=svec(), method=Typeof(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000028, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), SparseMatricesCOO.SparseMatrixCOO{Float64, Ti} where Ti<:Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228da60b40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), SparseMatricesCOO.SparseMatrixCOO{Float64, Ti} where Ti<:Integer}, sparams=svec(), method=size(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009744, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Base.SubArray{T, 1, P, I, L} where L where I where P where T, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226dc121c0)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Base.SubArray{T, 1, P, I, L} where L where I where P where T, 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.Broadcast.combine_styles), AbstractArray{T, 1} where T, AbstractArray{T, 1} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742272eb6ea0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), AbstractArray{T, 1} where T, AbstractArray{T, 1} where T}, sparams=svec(), method=combine_styles(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004832, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.:(/)), Tuple{FillArrays.Fill{Float64, 1, Tuple{Base.OneTo{Int64}}}, Array{T, 1} where T<:Number}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d96e480)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.:(/)), Tuple{FillArrays.Fill{Float64, 1, Tuple{Base.OneTo{Int64}}}, Array{T, 1} where T<:Number}}, sparams=svec(typeof(Base.:(/))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), Base.SubArray{_A, _B, P, I, false} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, var"#s179", typeof(Base.abs), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R} where var"#s179"<:Tuple}, limit=1), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226f3d3a60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.copyto!), Base.SubArray{_A, _B, P, I, false} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, var"#s179", typeof(Base.abs), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R} where var"#s179"<:Tuple}, sparams=svec(), method=copyto!(AbstractArray{T, N} where N where T, Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048c4, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.throw_boundserror), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742271309c80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.throw_boundserror), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Tuple{Int64}}, sparams=svec(), method=throw_boundserror(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000310, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.permute!), Array{_A, 1} where _A, Array{Int64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228ac1f900)[Core.MethodMatch(spec_types=Tuple{typeof(Base.permute!), Array{_A, 1} where _A, Array{Int64, 1}}, sparams=svec(), method=permute!(Any, AbstractArray{T, 1} where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000065b0, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)} where var"#s179"<:Tuple, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742282ed51a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)} where var"#s179"<:Tuple, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.axes), FillArrays.AbstractFill{T, N, Axes} where Axes where N where T}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseMatricesCOO.replace_if_minusinf), Real, Float64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422837b7b60)[Core.MethodMatch(spec_types=Tuple{typeof(SparseMatricesCOO.replace_if_minusinf), Float64, Float64}, sparams=svec(Float64), method=replace_if_minusinf(T, T) where {T}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009744, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Array{QuadraticModels.Col{T}, 1} where T, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228f38a080)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Array{QuadraticModels.Col{T}, 1} where T, 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.Broadcast.combine_styles), Base.RefValue{T} where T, AbstractArray{Float64, 1}, Float64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d2eec80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), Base.RefValue{T} where T, AbstractArray{Float64, 1}, Float64}, sparams=svec(), method=combine_styles(Any, Any, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004833, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.jac_nln_coord!), ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T, AbstractArray{T, 1} where T, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742285d9a7a0)[Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_nln_coord!), ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T}, sparams=svec(), method=jac_nln_coord!(Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096b3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IteratorSize}, Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Any, 1}}, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Int64, 1}}, Vararg{Pair{Symbol, _A} where _A, 4}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e399420)[Core.MethodMatch(spec_types=Tuple{Type{Base.IteratorSize}, Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Any, 1}}, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Int64, 1}}, Vararg{Pair{Symbol, _A} where _A, 4}}}, sparams=svec(), method=(::Type{Base.IteratorSize})(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000445, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._overflowind), Int64, Tuple{}, Tuple{Vararg{Int64, N}} where N}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422868ae0e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._overflowind), Int64, Tuple{}, Tuple{Vararg{Int64, N}} where N}, sparams=svec(), method=_overflowind(Any, Tuple{}, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000166d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eltype), AbstractArray{var"#s4711", 2} where var"#s4711"<:Float64}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74228a239ee0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.eltype), SparseArrays.ReadOnly{T, 2, V} where V<:AbstractArray{T, 2} where T<:Float64}, sparams=svec(), method=eltype(SparseArrays.ReadOnly{T, N, V} where V<:AbstractArray{T, N} where N where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.eltype), AbstractArray{var"#s4711", 2} where var"#s4711"<:Float64}, sparams=svec(), method=eltype(Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009675, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:name,), Tuple{String}}, Type{ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T}, SolverTest.var"#22#23", Array{Float64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228bb9b660)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:name,), Tuple{String}}, Type{ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T}, SolverTest.var"#22#23", Array{Float64, 1}}, sparams=svec(Array{Float64, 1}), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, Type{ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T}, Any, S) where {S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096b3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.SubArray{T, N, P, I, L} where L where I where P where N where T}, Base.IndexCartesian, AbstractArray{Float64, 1}, Tuple{Array{Int64, 1}}, Tuple{Bool}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742282f96d40)[Core.MethodMatch(spec_types=Tuple{Type{Base.SubArray{T, N, P, I, L} where L where I where P where N where T}, Base.IndexCartesian, AbstractArray{Float64, 1}, Tuple{Array{Int64, 1}}, Tuple{Bool}}, sparams=svec(P<:AbstractArray{Float64, 1}, Tuple{Array{Int64, 1}}, 1), method=(::Type{Base.SubArray{T, N, P, I, L} where L where I where P where N where T})(Base.IndexCartesian, P, I, Tuple{Vararg{Any, N}}) where {P, I, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002d92, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{Any, Tuple{Any, Vararg{Any}}}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742283e3a9a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{Any, Tuple{Any, Vararg{Any}}}, Int64, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000689, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{NamedTuple{(:shrink,), T} where T<:Tuple}, Tuple{Bool}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a6fbcee0)[Core.MethodMatch(spec_types=Tuple{Type{NamedTuple{(:shrink,), T} where T<:Tuple}, Tuple{Bool}}, sparams=svec((:shrink,)), 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{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, Any, Tuple{Any, Base.RefValue{T} where T, AbstractArray{Float64, 1}, Array{Float64, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74228865dbe0)[ Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, Tuple, Tuple{Any, Base.RefValue{T} where T, AbstractArray{Float64, 1}, Array{Float64, 1}}}, sparams=svec(), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, Tuple, Tuple), fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, Any, Tuple{Any, Base.RefValue{T} where T, AbstractArray{Float64, 1}, Array{Float64, 1}}}, sparams=svec(F), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple) where {F}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eltype), Type{var"#s179"} where var"#s179"<:Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Float64}, Pair{Symbol, _A} where _A}}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(6, 0x742288be4ed0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.eltype), Type{Union{}}}, sparams=svec(), method=eltype(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.eltype), Type{var"#s179"} where var"#s179"<:Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Float64}, Pair{Symbol, _A} where _A}}, sparams=svec(), method=eltype(Type{var"#s179"} where var"#s179"<:Tuple), fully_covers=true), #, #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001245, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, var"#s179", typeof(Base.abs), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R} where var"#s179"<:Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226f33a3a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, var"#s179", typeof(Base.abs), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R} where var"#s179"<:Tuple}, sparams=svec(), method=instantiate(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004803, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Generator{I, F} where F where I}, QuadraticModels.var"#get_hcols##0#get_hcols##1"{_A, Array{Int64, 1}} where _A, Base.UnitRange{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d9386a0)[Core.MethodMatch(spec_types=Tuple{Type{Base.Generator{I, F} where F where I}, QuadraticModels.var"#get_hcols##0#get_hcols##1"{_A, Array{Int64, 1}} where _A, Base.UnitRange{Int64}}, sparams=svec(Base.UnitRange{Int64}, F<:(QuadraticModels.var"#get_hcols##0#get_hcols##1"{_A, Array{Int64, 1}} where _A)), method=(::Type{Base.Generator{I, F} where F where I})(F, I) where {I, F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000420, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), Memory{V} where V<:(QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2} where T where S where M1 where M2)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226e2f7200)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), Memory{V} where V<:(QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2} where T where S where M1 where M2)}, sparams=svec(), method=size(GenericMemory{isatomic, T, addrspace} where addrspace where T where isatomic), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001033, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{ft} where ft<:Number, Float64}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), Tuple{Base.Broadcast.Extruded{FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Number)}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273bd5ca0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), Tuple{Base.Broadcast.Extruded{FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Number)}}, sparams=svec(), method=Typeof(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000028, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SolverCore.solve!), Union{RipQP.RipQPDoubleSolver{T, _A, Int64, _B, _C, Float64, T1, _D, _E, _F, _G} where _G<:(RipQP.PreallocatedFloatData{T1, _D, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T1, _D} where Dda<:RipQP.DescentDirectionAllocs{T1, _D} where Res<:RipQP.AbstractResiduals{T1, _D}) where _F<:(RipQP.Abstract_QM_FloatData{T, _A, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where _E<:(RipQP.Abstract_QM_FloatData{T1, _D, M1, M2} where M2<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}} where M1<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}}) where _D where T1<:Real where _C<:RipQP.ScaleData{T, _A} where _B<:QuadraticModels.AbstractQuadraticModel{T, _A} where _A, RipQP.RipQPDoubleSolver{T, _A, Int64, _B, _C, Float64, T1, S1, _E, _F, _G} where _G<:(RipQP.PreallocatedFloatData{T1, S1, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T1, S1} where Dda<:RipQP.DescentDirectionAllocs{T1, S1} where Res<:RipQP.AbstractResiduals{T1, S1}) where _F<:(RipQP.Abstract_QM_FloatData{T, _A, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where _E<:(RipQP.Abstract_QM_FloatData{T1, S1, M1, M2} where M2<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}} where M1<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}}) where S1 where T1<:Real where _C<:RipQP.ScaleData{T, _A} where _B<:QuadraticModels.AbstractQuadraticModel{T, _A} where _A, RipQP.RipQPDoubleSolver{T, S, Int64, _B, _C, Float64, T1, _D, _E, _F, _G} where _G<:(RipQP.PreallocatedFloatData{T1, _D, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T1, _D} where Dda<:RipQP.DescentDirectionAllocs{T1, _D} where Res<:RipQP.AbstractResiduals{T1, _D}) where _F<:(RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where _E<:(RipQP.Abstract_QM_FloatData{T1, _D, M1, M2} where M2<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}} where M1<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}}) where _D where T1<:Real where _C<:RipQP.ScaleData{T, S} where _B<:QuadraticModels.AbstractQuadraticModel{T, S} where S, RipQP.RipQPDoubleSolver{T, S, Int64, _B, _C, Float64, T1, S1, _E, _F, _G} where _G<:(RipQP.PreallocatedFloatData{T1, S1, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T1, S1} where Dda<:RipQP.DescentDirectionAllocs{T1, S1} where Res<:RipQP.AbstractResiduals{T1, S1}) where _F<:(RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where _E<:(RipQP.Abstract_QM_FloatData{T1, S1, M1, M2} where M2<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}} where M1<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}}) where S1 where T1<:Real where _C<:RipQP.ScaleData{T, S} where _B<:QuadraticModels.AbstractQuadraticModel{T, S} where S} where T<:Real, QuadraticModels.QuadraticModel{T, S, M1, M2} where M2 where M1 where S where T, SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T, RipQP.RipQPDoubleParameters{T, SP1, _A, RipQP.PC, RipQP.PC} where _A<:RipQP.SolverParams{T} where SP1<:(RipQP.K2LDLParams{_A, RipQP.LDLFact} where _A) where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226ca36e60)[Core.MethodMatch(spec_types=Tuple{typeof(SolverCore.solve!), RipQP.RipQPDoubleSolver{T, S, Int64, _B, _C, Float64, T1, S1, _E, _F, _G} where _G<:(RipQP.PreallocatedFloatData{T1, S1, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T1, S1} where Dda<:RipQP.DescentDirectionAllocs{T1, S1} where Res<:RipQP.AbstractResiduals{T1, S1}) where _F<:(RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where _E<:(RipQP.Abstract_QM_FloatData{T1, S1, M1, M2} where M2<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}} where M1<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}}) where S1 where T1<:Real where _C<:RipQP.ScaleData{T, S} where _B<:QuadraticModels.AbstractQuadraticModel{T, S}, QuadraticModels.QuadraticModel{T, S, M1, M2} where M2 where M1, SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V, RipQP.RipQPDoubleParameters{T, SP1, _A, RipQP.PC, RipQP.PC} where _A<:RipQP.SolverParams{T} where SP1<:(RipQP.K2LDLParams{_A, RipQP.LDLFact} where _A) where T<:Real} where S where T<:Real, sparams=svec(T<:Real, S), method=solve!(RipQP.RipQPDoubleSolver{T, S, I, QMType, Sd, Tsc, T1, S1, QMfd1, QMfd2, Pfd} where Pfd<:(RipQP.PreallocatedFloatData{T1, S1, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T1, S1} where Dda<:RipQP.DescentDirectionAllocs{T1, S1} where Res<:RipQP.AbstractResiduals{T1, S1}) where QMfd2<:(RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where QMfd1<:(RipQP.Abstract_QM_FloatData{T1, S1, M1, M2} where M2<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}} where M1<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}}) where S1 where T1 where Tsc<:Real where Sd<:RipQP.ScaleData{T, S} where QMType<:QuadraticModels.AbstractQuadraticModel{T, S} where I, QuadraticModels.AbstractQuadraticModel{T, S}, SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V, RipQP.RipQPDoubleParameters{T, SP1, SP2, SM1, SM2} where SM2<:RipQP.SolveMethod where SM1<:RipQP.SolveMethod where SP2<:RipQP.SolverParams{T} where SP1<:(RipQP.SolverParams{T} where T) where T<:Real) where {T, S}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(OperatorScaling.mul_Q_D!), AbstractArray{var"#s4711", 2} where var"#s4711"<:Real, Array{T, 1} where T<:Real, LinearAlgebra.Diagonal{T, Array{T, 1}} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226ead26e0)[ Core.MethodMatch(spec_types=Tuple{typeof(OperatorScaling.mul_Q_D!), SparseArrays.SparseMatrixCSC{var"#s4711", Ti} where Ti<:Integer where var"#s4711"<:Real, Array{T, 1} where T<:Real, LinearAlgebra.Diagonal{T, Array{T, 1}} where T<:Real}, sparams=svec(), method=mul_Q_D!(SparseArrays.SparseMatrixCSC{Tv, Ti} where Ti<:Integer where Tv, Any, Any), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(OperatorScaling.mul_Q_D!), AbstractArray{var"#s4711", 2} where var"#s4711"<:Real, Array{T, 1} where T<:Real, LinearAlgebra.Diagonal{T, Array{T, 1}} where T<:Real}, sparams=svec(), method=mul_Q_D!(Any, Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Base.RefValue{typeof(Base.abs)}, Any} where var"#s175"<:Tuple{Base.RefValue{typeof(Base.abs)}, Any}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742274495fa0)[Core.MethodMatch(spec_types=Tuple{Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Base.RefValue{typeof(Base.abs)}, Any} where var"#s175"<:Tuple{Base.RefValue{typeof(Base.abs)}, Any}, Int64}, sparams=svec(var"#s175"<:Tuple{Base.RefValue{typeof(Base.abs)}, Any}), method=(::Base.var"#cvt1#convert##0"{T, x})(Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000376, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:(Array{Tv, 1} where Tv<:Number), Array{Tv, 1} where Tv<:Number}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74228e9b2da0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Array{Tv, 1} where Tv<:Number}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:(Array{Tv, 1} where Tv<:Number), Array{Tv, 1} where Tv<:Number}, sparams=svec(var"#s175"<:(Array{Tv, 1} where Tv<:Number)), method=convert(Type{T}, AbstractArray{T, N} where N where T) where {T<:(Array{T, N} where N where T)}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010dd, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.collect), Base.Generator{I, typeof(Base.identity)} where I<:(Base.LogicalIndex{T, A} where A<:(AbstractArray{Bool, N} where N) where T)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228645a840)[Core.MethodMatch(spec_types=Tuple{typeof(Base.collect), Base.Generator{I, typeof(Base.identity)} where I<:(Base.LogicalIndex{T, A} where A<:(AbstractArray{Bool, N} where N) where T)}, sparams=svec(), method=collect(Base.Generator{I, F} where F where I), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001101, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(<=)), Array{T, 1} where T<:Real, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7422833e3ce0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(<=)), Array{T, 1} where T<:Real, Any}, sparams=svec(typeof(Base.:(<=))), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004959, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.error_if_canonical_setindex), Base.IndexLinear, Array{Int64, 1}, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74227429cc60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.error_if_canonical_setindex), Base.IndexLinear, Array{Int64, 1}, Int64}, sparams=svec(), method=error_if_canonical_setindex(Base.IndexLinear, AbstractArray{T, N} where N where T, Int64), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.error_if_canonical_setindex), Base.IndexLinear, Array{Int64, 1}, Any}, sparams=svec(), method=error_if_canonical_setindex(Base.IndexStyle, AbstractArray{T, N} where N where T, Any...), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012fe, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LinearAlgebra.ishermitian), SparseArrays.SparseMatrixCSC{T, Int64} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a9a63ca0)[Core.MethodMatch(spec_types=Tuple{typeof(LinearAlgebra.ishermitian), SparseArrays.SparseMatrixCSC{T, Int64} where T<:Real}, sparams=svec(), method=ishermitian(SparseArrays.AbstractSparseMatrixCSC{Tv, Ti} where Ti<:Integer where Tv), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009675, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Iterators._zip_iterate_interleave), Tuple{Tuple{Int64, Int64}}, Tuple{Any}, Tuple{Base.Missing, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273b18220)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators._zip_iterate_interleave), Tuple{Tuple{Int64, Int64}}, Tuple{Any}, Tuple{Base.Missing, Any}}, sparams=svec(), method=_zip_iterate_interleave(Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000018ca, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), Array{Int64, 1}, Any, Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x742274584120)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Array{Int64, 1}, Any, Int64}, sparams=svec(Int64), method=setindex!(Array{T, N} where N, Any, Int64) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Array{Int64, 1}, Any, Integer}, sparams=svec(), method=setindex!(Array{T, N} where N where T, Any, Union{Integer, Base.IteratorsMD.CartesianIndex{N} where N}, Union{Integer, Base.IteratorsMD.CartesianIndex{N} where N}...), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004676, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(-)), Base.SubArray{T, N, P, I, L} where L where I where P where N where T, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7422a779b660)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(-)), Base.SubArray{T, N, P, I, L} where L where I where P where N where T, Any}, sparams=svec(typeof(Base.:(-))), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004959, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{NamedTuple{(:shift, :check), T} where T<:Tuple}, Tuple{Float64, Bool}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74227317d320)[Core.MethodMatch(spec_types=Tuple{Type{NamedTuple{(:shift, :check), T} where T<:Tuple}, Tuple{Float64, Bool}}, sparams=svec((:shift, :check)), 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{Type{Base.Broadcast.BroadcastStyle}, Type{FillArrays.Fill{T, N, Axes}} where Axes where N where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7422748a73e0)[ Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.BroadcastStyle}, Type{FillArrays.Fill{T, N, Axes}} where Axes where N where T}, sparams=svec(T, N), method=(::Type{Base.Broadcast.BroadcastStyle})(Type{var"#s677"} where var"#s677"<:AbstractArray{T, N}) where {T, N}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000479b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{QuadraticModels.QPData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S where T}, Any, Any, Any, SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv, SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228c98b5a0)[Core.MethodMatch(spec_types=Tuple{Type{QuadraticModels.QPData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S where T}, Any, S, S, M1, M2} where M2<:(SparseMatricesCOO.SparseMatrixCOO{T, Ti} where Ti<:Integer) where M1<:(SparseMatricesCOO.SparseMatrixCOO{T, Ti} where Ti<:Integer) where S where T, sparams=svec(T, S, M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}, M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}), method=(::Type{QuadraticModels.QPData{T, S, M1, M2} where M2 where M1 where S where T})(T, S, S, M1, M2) where {T, S, M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}, M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009745, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Type{SparseArrays.CHOLMOD.Sparse{Tv, Int32}} where Tv<:Union{Float32, Float64}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228bba0e40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Type{SparseArrays.CHOLMOD.Sparse{Tv, Int32}} where Tv<:Union{Float32, Float64}, 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{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.RefValue{typeof(Base.:(>))}, AbstractArray{Float64, 1}, AbstractArray{Float64, 1}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422835ee1e0)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.RefValue{typeof(Base.:(>))}, AbstractArray{Float64, 1}, AbstractArray{Float64, 1}}}}, sparams=svec(), method=(::Type{MethodError})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000009d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(OperatorScaling.get_norm_rc!), Array{Float64, 1}, LinearAlgebra.Symmetric{Float64, S} where S<:(AbstractArray{var"#s4711", 2} where var"#s4711"<:Float64), Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226d3a9de0)[ Core.MethodMatch(spec_types=Tuple{typeof(OperatorScaling.get_norm_rc!), Array{Float64, 1}, LinearAlgebra.Symmetric{Float64, SparseArrays.SparseMatrixCSC{Float64, Int64}}, Symbol}, sparams=svec(Float64), method=get_norm_rc!(AbstractArray{T, 1}, LinearAlgebra.Symmetric{T, SparseArrays.SparseMatrixCSC{T, Int64}}, Any) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(OperatorScaling.get_norm_rc!), Array{Float64, 1}, LinearAlgebra.Symmetric{Float64, S} where S<:(AbstractArray{var"#s4711", 2} where var"#s4711"<:Float64), Symbol}, sparams=svec(Float64), method=get_norm_rc!(AbstractArray{T, 1}, Any, Any) where {T}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(/)), Base.TwicePrecision{T} where T<:Union{Float16, Float32, Float64}, Base.TwicePrecision{Float16}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228760f400)[Core.MethodMatch(spec_types=Tuple{typeof(Base.:(/)), Base.TwicePrecision{T} where T<:Union{Float16, Float32, Float64}, Base.TwicePrecision{Float16}}, sparams=svec(), method=/(Base.TwicePrecision{T} where T, Base.TwicePrecision{T} where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002ef1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LinearAlgebra.ldiv!), LinearAlgebra.Diagonal{Float64, Array{Float64, 1}}, AbstractArray{var"#s4711", 2} where var"#s4711"<:Float64}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.tail), Tuple{Base.Missing, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273ab1b40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.tail), Tuple{Base.Missing, Any}}, sparams=svec(), method=tail(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000035d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Iterators.Reverse{T} where T}, Base.IteratorsMD.CartesianIndices{1, Tuple{Base.StepRange{Int64, Int64}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742289e35080)[Core.MethodMatch(spec_types=Tuple{Type{Base.Iterators.Reverse{T} where T}, Base.IteratorsMD.CartesianIndices{1, Tuple{Base.StepRange{Int64, Int64}}}}, sparams=svec(Base.IteratorsMD.CartesianIndices{1, Tuple{Base.StepRange{Int64, Int64}}}), method=(::Type{Base.Iterators.Reverse{T} where T})(T) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001863, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(QuadraticModels.postsolve), QuadraticModels.PresolvedData{T, S} where S<:AbstractArray{T, 1} where T<:Real, QuadraticModels.QMSolution{S, V} where V where S<:AbstractArray{T, 1} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422888a5c20)[Core.MethodMatch(spec_types=Tuple{typeof(QuadraticModels.postsolve), QuadraticModels.PresolvedData{T, S}, QuadraticModels.QMSolution{S, V} where V} where S<:AbstractArray{T, 1} where T<:Real, sparams=svec(T<:Real, S<:AbstractArray{T<:Real, 1}), method=postsolve(QuadraticModels.PresolvedData{T, S}, QuadraticModels.QMSolution{S, V} where V) where {T, S}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009745, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.convert_QM), QuadraticModels.QuadraticModel{T, S, M1, M2} where M2 where M1 where S<:AbstractArray{T, 1} where T<:Real, Bool, Bool, RipQP.SolverParams{T} where T<:Real, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742289a01ee0)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.convert_QM), QuadraticModels.QuadraticModel{T, S, M1, M2} where M2 where M1 where S<:AbstractArray{T, 1} where T<:Real, Bool, Bool, RipQP.SolverParams{T} where T<:Real, Bool}, sparams=svec(T<:Real, S<:AbstractArray{T<:Real, 1}, M1, M2), method=convert_QM(QuadraticModels.QuadraticModel{T, S, M1, M2}, Bool, Bool, RipQP.SolverParams{T} where T, Bool) where {T, S, M1, M2}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.tagcount), Type{ForwardDiff.Tag{_A, Float64}} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74227469c1e0)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.tagcount), Type{ForwardDiff.Tag{_A, Float64}} where _A}, sparams=svec(_A, Float64), method=tagcount(Type{ForwardDiff.Tag{F, V}}) where {F, V}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009697, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.to_indices), Array{Ti, 1} where Ti<:Integer, Tuple{Union{Integer, Base.IteratorsMD.CartesianIndex{N} where N}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(6, 0x7422848eb3b0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.to_indices), Array{Ti, 1} where Ti<:Integer, Tuple{Int64}}, sparams=svec(), method=to_indices(Any, Tuple{Vararg{Int64}}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.to_indices), Array{Ti, 1} where Ti<:Integer, Tuple{Integer}}, sparams=svec(), method=to_indices(Any, Tuple{Vararg{Integer}}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.to_indices), Array{Ti, 1} where Ti<:Integer, Tuple{Union{Integer, Base.IteratorsMD.CartesianIndex{N} where N}}}, sparams=svec(), method=to_indices(Any, Tuple{Vararg{Union{Integer, Base.IteratorsMD.CartesianIndex{N} where N}}}), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000046ae, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.zero), Type{ForwardDiff.Partials{_A, Float64}} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422878d72a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.zero), Type{ForwardDiff.Partials{_A, Float64}} where _A}, sparams=svec(_A, Float64), method=zero(Type{ForwardDiff.Partials{N, V}}) where {N, V}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009697, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Base.UnitRange{Int64}}, Base.UnitRange{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226eaf2ba0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Base.UnitRange{Int64}}, Base.UnitRange{Int64}}, sparams=svec(Base.UnitRange{Int64}), method=convert(Type{T}, Base.AbstractRange{T} where T) where {T<:(Base.AbstractRange{T} where T)}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000875, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Number)}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74227393f980)[Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Number)}, Int64}, sparams=svec(), method=checkbounds(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Integer), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004886, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{NamedTuple{(:μ₀, :μ₁, :σ), T} where T<:Tuple}, Tuple{Any, Any, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228bc80ba0)[Core.MethodMatch(spec_types=Tuple{Type{NamedTuple{(:μ₀, :μ₁, :σ), T} where T<:Tuple}, Tuple{Any, Any, Any}}, sparams=svec((:μ₀, :μ₁, :σ)), 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{Type{SolverTools.TrustRegionException}, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228cc86d40)[Core.MethodMatch(spec_types=Tuple{Type{SolverTools.TrustRegionException}, String}, sparams=svec(), method=(::Type{SolverTools.TrustRegionException})(String), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096c0, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._array_for), Type{QuadraticModels.Col{T}} where T, Base.HasShape{1}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e9e0900)[Core.MethodMatch(spec_types=Tuple{typeof(Base._array_for), Type{QuadraticModels.Col{T}} where T, Base.HasShape{1}, Tuple{Base.OneTo{Int64}}}, sparams=svec(T<:(QuadraticModels.Col{T} where T), 1), method=_array_for(Type{T}, Base.HasShape{N}, Any) where {T, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010f1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isbitstype), Type{NLPModels.NLPModelMeta{T, S}} where S where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a8939720)[Core.MethodMatch(spec_types=Tuple{typeof(Base.isbitstype), Type{NLPModels.NLPModelMeta{T, S}} where S where T}, sparams=svec(), method=isbitstype(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000503, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.signature_type), NLPModels.var"#27#28"{var"#s179", ADNLPModels.ADNLPModel{T, S, Si}, var"#s179", var"#s179", typeof(Base.:(*)), typeof(Base.:(+))} where var"#s179"<:AbstractArray{T, 1} where T where var"#s179"<:AbstractArray{T, 1} where T where Si where S<:AbstractArray{T, 1} where T where var"#s179"<:Real, Type{Tuple}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228cf81a40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.signature_type), NLPModels.var"#27#28"{var"#s179", ADNLPModels.ADNLPModel{T, S, Si}, var"#s179", var"#s179", typeof(Base.:(*)), typeof(Base.:(+))} where var"#s179"<:AbstractArray{T, 1} where T where var"#s179"<:AbstractArray{T, 1} where T where Si where S<:AbstractArray{T, 1} where T where var"#s179"<:Real, Type{Tuple}}, sparams=svec(), method=signature_type(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000546, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{SolverTools.var"#_#10#11", Any, Any, Any, Any, Any, Any, Any, Type{SolverTools.TRONTrustRegion{T, V} where V where T}, Any, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228cd7b960)[Core.MethodMatch(spec_types=Tuple{SolverTools.var"#_#10#11", T, T, T, T, T, T, T, Type{SolverTools.TRONTrustRegion{T, V} where V where T}, V, T} where V where T, sparams=svec(T, V), method=_(T, T, T, T, T, T, T, Type{SolverTools.TRONTrustRegion{T, V} where V where T}, V, T) where {T, V}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096c0, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LinearOperators.storage_type), LinearOperators.AdjointLinearOperator{T, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}} where T where I<:Integer where F where Ft where Fct where S where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d881980)[Core.MethodMatch(spec_types=Tuple{typeof(LinearOperators.storage_type), LinearOperators.AdjointLinearOperator{T, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}} where T where I<:Integer where F where Ft where Fct where S where T}, sparams=svec(), method=storage_type(Union{LinearOperators.AdjointLinearOperator{T, S} where S where T, LinearOperators.TransposeLinearOperator{T, S} where S where T}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), Tuple{typeof(DataType)}}, typeof(LinearOperators.CompositeLinearOperator), Any, Any, Int64, Bool, Bool, LinearOperators.var"#*##0#*##1"{LinearOperators.AdjointLinearOperator{T, S}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}, _A} where _A where S where Fct where Ft where F where I<:Integer where T where S where T, LinearOperators.var"#*##2#*##3"{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}, LinearOperators.AdjointLinearOperator{T, S}, _A} where _A where S where T where S where Fct where Ft where F where I<:Integer where T, LinearOperators.var"#*##4#*##5"{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}, LinearOperators.AdjointLinearOperator{T, S}, _A} where _A where S where T where S where Fct where Ft where F where I<:Integer where T, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d662920)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), Tuple{typeof(DataType)}}, typeof(LinearOperators.CompositeLinearOperator), Type, Int64, Int64, Bool, Bool, F, Ft, Fct, Bool} where Fct<:(LinearOperators.var"#*##4#*##5"{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}, LinearOperators.AdjointLinearOperator{T, S}, _A} where _A where S where T where S where Fct where Ft where F where I<:Integer where T) where Ft<:(LinearOperators.var"#*##2#*##3"{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}, LinearOperators.AdjointLinearOperator{T, S}, _A} where _A where S where T where S where Fct where Ft where F where I<:Integer where T) where F<:(LinearOperators.var"#*##0#*##1"{LinearOperators.AdjointLinearOperator{T, S}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}, _A} where _A where S where Fct where Ft where F where I<:Integer where T where S where T), sparams=svec(Int64, F<:F<:(LinearOperators.var"#*##0#*##1"{LinearOperators.AdjointLinearOperator{T, S}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}, _A} where _A where S where Fct where Ft where F where I<:Integer where T where S where T), Ft<:Ft<:(LinearOperators.var"#*##2#*##3"{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}, LinearOperators.AdjointLinearOperator{T, S}, _A} where _A where S where T where S where Fct where Ft where F where I<:Integer where T), Fct<:Fct<:(LinearOperators.var"#*##4#*##5"{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S}, LinearOperators.AdjointLinearOperator{T, S}, _A} where _A where S where T where S where Fct where Ft where F where I<:Integer where T)), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(LinearOperators.CompositeLinearOperator), Type, I, I, Bool, Bool, F, Ft, Fct, Bool) where {I<:Integer, F, Ft, Fct}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.preprocess), Base.BitArray{1}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.imag), var"#s179"} where var"#s179"<:Tuple{Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a94a5a60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.preprocess), Base.BitArray{1}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.imag), var"#s179"} where var"#s179"<:Tuple{Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64}}}, sparams=svec(), method=preprocess(Any, Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048ca, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkindex), Type{Bool}, Any, Int64}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Array{_A, 1} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a6d08760)[Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Array{_A, 1} where _A}, sparams=svec(), method=checkbounds(AbstractArray{T, N} where N where T, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000127b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.dotgetproperty), LinearAlgebra.Diagonal{Float64, S} where S<:AbstractArray{Float64, 1}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d29edc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.dotgetproperty), LinearAlgebra.Diagonal{Float64, S} where S<:AbstractArray{Float64, 1}, Symbol}, sparams=svec(), method=dotgetproperty(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000286, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Tuple{Base.Broadcast.Extruded{FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Number)}, Int64}, limit=3), Base.Compiler.MethodLookupResult(]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000177d, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.length), Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Any, 1}}, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Int64, 1}}, Vararg{Pair{Symbol, _A} where _A, 4}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e37f640)[Core.MethodMatch(spec_types=Tuple{typeof(Base.length), Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Any, 1}}, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Int64, 1}}, Vararg{Pair{Symbol, _A} where _A, 4}}}, sparams=svec(), method=length(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000664, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, L} where L<:Integer}, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Integer, Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228a6b3320)[Core.MethodMatch(spec_types=Tuple{Type{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, L} where L<:Integer}, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Integer, Integer}, sparams=svec(Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}), method=(::Type{Base.StepRangeLen{T, R, S, L} where L<:Integer})(R, S, Integer, Integer) where {T, R, S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000008b3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.get), Base.IdDict{Any, Any}, Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a7701be0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.get), Base.IdDict{Any, Any}, Real, Symbol}, sparams=svec(Any, Any), method=get(Base.IdDict{K, V}, Any, Any) where {K, V}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000017a3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), AbstractArray{Float64, 1}, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742283188540)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), AbstractArray{Float64, 1}, Any}, sparams=svec(), method=combine_styles(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004832, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.initialize!), RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S where T<:Real, RipQP.QM_IntData, RipQP.AbstractResiduals{T, S} where S where T<:Real, RipQP.IterData{T, S} where S where T<:Real, RipQP.DescentDirectionAllocs{T, S} where S where T<:Real, RipQP.PreallocatedData{T, S} where S where T<:Real, RipQP.Point{T, S} where S where T<:Real, RipQP.StartingPointData{T, S} where S where T<:Real, RipQP.Tolerances{T} where T<:Real, RipQP.StopCrit{Float64}, RipQP.Counters, Float64, Bool, Type{Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742284227000)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.initialize!), RipQP.QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S, RipQP.QM_IntData, RipQP.AbstractResiduals{T, S} where S, RipQP.IterData{T, S} where S, RipQP.DescentDirectionAllocs{T, S} where S, RipQP.PreallocatedData{T, S} where S, RipQP.Point{T, S} where S, RipQP.StartingPointData{T, S} where S, RipQP.Tolerances{T}, RipQP.StopCrit{Float64}, RipQP.Counters, Float64, Bool, Type{Float64}} where T<:Real, sparams=svec(T<:Real, Float64, Float64), method=initialize!(RipQP.QM_FloatData{T, S, M1, M2} where M2 where M1 where S, RipQP.QM_IntData, RipQP.AbstractResiduals{T, S} where S, RipQP.IterData{T, S} where S, RipQP.DescentDirectionAllocs{T, S} where S, RipQP.PreallocatedData{T, S} where S, RipQP.Point{T, S} where S, RipQP.StartingPointData{T, S} where S, RipQP.Tolerances{T}, RipQP.StopCrit{Tc}, RipQP.Counters, Float64, Bool, Type{T0}) where {T<:Real, Tc<:Real, T0<:Real}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.print), Base.GenericIOBuffer{Memory{UInt8}}, Type{Array{Tv, 1}} where Tv<:Number}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74228e538e60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.print), Base.GenericIOBuffer{Memory{UInt8}}, Type{Array{Tv, 1}} where Tv<:Number}, sparams=svec(), method=print(IO, Any), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003da3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(QuadraticModels.restore_x!), Array{Bool, 1}, Any, Any, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742283dca100)[Core.MethodMatch(spec_types=Tuple{typeof(QuadraticModels.restore_x!), Array{Bool, 1}, S, S, Int64} where S, sparams=svec(S<:S), method=restore_x!(Any, S, S, Any) where {S}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009745, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_type), Type{typeof(DataType)}, typeof(DataType), typeof(DataType)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e77aae0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_type), Type{typeof(DataType)}, typeof(DataType), typeof(DataType)}, sparams=svec(), method=promote_type(Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000005f3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Returns{V} where V}, Base.OneTo{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422865125e0)[Core.MethodMatch(spec_types=Tuple{Type{Base.Returns{V} where V}, Base.OneTo{Int64}}, sparams=svec(), method=(::Type{Base.Returns{V} where V})(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c19, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unsafe_copyto!), GenericMemoryRef{:not_atomic, T, Core.AddrSpace{Core}(0x00)} where T<:Real, GenericMemoryRef{:not_atomic, T, Core.AddrSpace{Core}(0x00)} where T<:Real, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x742289a4e2e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_copyto!), GenericMemoryRef{:not_atomic, T, Core.AddrSpace{Core}(0x00)}, GenericMemoryRef{:not_atomic, T, Core.AddrSpace{Core}(0x00)}, Int64} where T<:Real, sparams=svec(T<:Real), method=unsafe_copyto!(GenericMemoryRef{:not_atomic, T, Core.AddrSpace{Core}(0x00)}, GenericMemoryRef{:not_atomic, T, Core.AddrSpace{Core}(0x00)}, Any) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_copyto!), GenericMemoryRef{:not_atomic, T, Core.AddrSpace{Core}(0x00)} where T<:Real, GenericMemoryRef{:not_atomic, T, Core.AddrSpace{Core}(0x00)} where T<:Real, Int64}, sparams=svec(), method=unsafe_copyto!(GenericMemoryRef{isatomic, T, addrspace} where addrspace where T where isatomic, GenericMemoryRef{isatomic, T, addrspace} where addrspace where T where isatomic, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001043, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, SparseArrays.HigherOrderFns.PromoteToSparse, typeof(SparseMatricesCOO.replace_if_minusinf), Tuple{LinearAlgebra.Adjoint{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where Float64<:T<:Real, Int64}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742287b8db20)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, SparseArrays.HigherOrderFns.PromoteToSparse, typeof(SparseMatricesCOO.replace_if_minusinf), Tuple{LinearAlgebra.Adjoint{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where Float64<:T<:Real, Int64}, Nothing}, sparams=svec(typeof(SparseMatricesCOO.replace_if_minusinf)), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{FillArrays.Fill{Float64, 1, Axes} where Axes}, Float64, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742286b7a0c0)[Core.MethodMatch(spec_types=Tuple{Type{FillArrays.Fill{Float64, 1, Axes} where Axes}, Float64, Tuple{Base.OneTo{Int64}}}, sparams=svec(Float64, 1, Tuple{Base.OneTo{Int64}}), method=(::Type{FillArrays.Fill{T, N, Axes} where Axes})(Any, Axes) where {T, N, Axes<:Tuple{Vararg{Base.AbstractUnitRange{T} where T, N}}}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009681, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{Base.Fix{1, typeof(Base.to_index), LinearAlgebra.Diagonal{T, V}} where V<:Array{T, 1} where T<:Real, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e3291e0)[Core.MethodMatch(spec_types=Tuple{Base.Fix{1, typeof(Base.to_index), LinearAlgebra.Diagonal{T, V}} where V<:Array{T, 1} where T<:Real, Int64}, sparams=svec(), method=(::Base.Fix{1, F, T})(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c4d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(<=)), FixedPointNumbers.Fixed{T, f} where f where T<:Signed, FixedPointNumbers.Fixed{T, f} where f where T<:Signed}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7422aa6a3120)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.:(<=)), X, X} where X<:(FixedPointNumbers.Fixed{T, f} where f where T<:Signed), sparams=svec(X<:X<:(FixedPointNumbers.Fixed{T, f} where f where T<:Signed)), method=<=(X, X) where {X<:(FixedPointNumbers.FixedPoint{T, f} where f where T<:Integer)}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.:(<=)), FixedPointNumbers.Fixed{T, f} where f where T<:Signed, FixedPointNumbers.Fixed{T, f} where f where T<:Signed}, sparams=svec(), method=<=(Real, Real), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000972d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._setindex!), Base.IndexCartesian, Base.SubArray{T, 2, P, I, L} where L where I where P where T, Any, Vararg{Any}}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.BroadcastStyle}, Base.Broadcast.DefaultArrayStyle{1}, Base.Broadcast.DefaultArrayStyle{N} where N}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(6, 0x74228dd794c0)[ Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.BroadcastStyle}, Base.Broadcast.DefaultArrayStyle{1}, Base.Broadcast.DefaultArrayStyle{1}}, sparams=svec(1), method=(::Type{Base.Broadcast.BroadcastStyle})(Base.Broadcast.AbstractArrayStyle{N}, Base.Broadcast.DefaultArrayStyle{N}) where {N}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.BroadcastStyle}, Base.Broadcast.DefaultArrayStyle{1}, Base.Broadcast.DefaultArrayStyle{N} where N}, sparams=svec(1, N), method=(::Type{Base.Broadcast.BroadcastStyle})(Base.Broadcast.AbstractArrayStyle{M}, Base.Broadcast.DefaultArrayStyle{N}) where {M, N}, fully_covers=true), #, #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047ad, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Nothing, typeof(Base.:(-)), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a952ecc0)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Nothing, typeof(Base.:(-)), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Tuple{Base.OneTo{Int64}}}, sparams=svec(typeof(Base.:(-))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{ReverseDiff.SpecialInstruction{F, I, O, C} where C where O where I where F}, typeof(Base.:(*)), Tuple{LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4711", 2} where var"#s4711"<:T) where T, ReverseDiff.TrackedArray{V, D, 1, VA, DA} where DA where VA where D where V}, ReverseDiff.TrackedArray{V, D, N, VA, DA} where DA where VA where N where D where V, Tuple{Any, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422742462c0)[Core.MethodMatch(spec_types=Tuple{Type{ReverseDiff.SpecialInstruction{F, I, O, C} where C where O where I where F}, typeof(Base.:(*)), Tuple{LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4711", 2} where var"#s4711"<:T) where T, ReverseDiff.TrackedArray{V, D, 1, VA, DA} where DA where VA where D where V}, ReverseDiff.TrackedArray{V, D, N, VA, DA} where DA where VA where N where D where V, Tuple{Any, Any}}, sparams=svec(), method=(::Type{ReverseDiff.SpecialInstruction{F, I, O, C} where C where O where I where F})(Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IOContext{IO_t} where IO_t<:IO}, Base.GenericIOBuffer{Memory{UInt8}}, Pair{Symbol, Array{T, 1}} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74227376b400)[Core.MethodMatch(spec_types=Tuple{Type{Base.IOContext{IO_t} where IO_t<:IO}, Base.GenericIOBuffer{Memory{UInt8}}, Pair{Symbol, Array{T, 1}} where T<:Real}, sparams=svec(), method=(::Type{Base.IOContext{IO_t} where IO_t<:IO})(IO, Pair{A, B} where B where A), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004148, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.typejoin), Type{Tuple{String, Function}}, Type{Tuple{String, Main.var"#tests##4#tests##5"{Main.var"#tests##6#tests##7"}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228f07e320)[Core.MethodMatch(spec_types=Tuple{typeof(Base.typejoin), Type{Tuple{String, Function}}, Type{Tuple{String, Main.var"#tests##4#tests##5"{Main.var"#tests##6#tests##7"}}}}, sparams=svec(), method=typejoin(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000005e0, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.update_K!), LinearAlgebra.Symmetric{T, _B} where _B<:AbstractArray{T, 2} where T<:Real, AbstractArray{T, 1} where T<:Real, RipQP.Regularization{T} where T<:Real, AbstractArray{T, 1} where T<:Real, AbstractArray{T, 1} where T<:Real, AbstractArray{T, 1} where T<:Real, AbstractArray{T, 1} where T<:Real, Array{Int64, 1}, Array{Int64, 1}, SparseArrays.SparseVector{T, Int64} where T<:Real, Array{Int64, 1}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d7f2660)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.update_K!), LinearAlgebra.Symmetric{T, _B} where _B<:AbstractArray{T, 2}, AbstractArray{T, 1}, RipQP.Regularization{T} where T<:Real, AbstractArray{T, 1}, AbstractArray{T, 1}, AbstractArray{T, 1}, AbstractArray{T, 1}, Array{Int64, 1}, Array{Int64, 1}, SparseArrays.SparseVector{T, Int64}, Array{Int64, 1}, Int64, Int64} where T<:Real, sparams=svec(T<:Real), method=update_K!(LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4711", 2} where var"#s4711"<:T), AbstractArray{T, 1}, RipQP.Regularization{T} where T<:Real, AbstractArray{T, 1}, AbstractArray{T, 1}, AbstractArray{T, 1}, AbstractArray{T, 1}, Any, Any, SparseArrays.AbstractSparseArray{T, Ti, 1} where Ti, Any, Any, Any) where {T}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), LinearAlgebra.Adjoint{T, Array{T, 1}} where T<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422868adba0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), LinearAlgebra.Adjoint{T, Array{T, 1}} where T<:Real, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eltype), Type{SparseArrays.CHOLMOD.Dense{Tv}} where Tv<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226f1704a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.eltype), Type{SparseArrays.CHOLMOD.Dense{Tv}} where Tv<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}}, sparams=svec(Tv<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}), method=eltype(Type{var"#s179"} where var"#s179"<:(AbstractArray{E, N} where N)) where {E}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001247, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.LinearIndices{N, R} where R<:Tuple{Vararg{Base.AbstractUnitRange{Int64}, N}} where N}, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228a292aa0)[Core.MethodMatch(spec_types=Tuple{Type{Base.LinearIndices{N, R} where R<:Tuple{Vararg{Base.AbstractUnitRange{Int64}, N}} where N}, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(), method=(::Type{Base.LinearIndices{N, R} where R<:Tuple{Vararg{Base.AbstractUnitRange{Int64}, N}} where N})(Union{Core.SimpleVector, AbstractArray{T, N} where N where T}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001017, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Tuple}, Base.Generator{Base.UnitRange{Int64}, Base.var"#ntuple##0#ntuple##1"{Base.Returns{Bool}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a79d1940)[Core.MethodMatch(spec_types=Tuple{Type{Tuple}, Base.Generator{Base.UnitRange{Int64}, Base.var"#ntuple##0#ntuple##1"{Base.Returns{Bool}}}}, sparams=svec(Tuple), method=(::Type{T})(Any) where {T<:Tuple}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006e5, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(!=)), Any, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), var"#s179"} where var"#s179"<:Tuple{Type}, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##4#PreconditionerData##5"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real, Nothing, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742271404300)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), var"#s179"} where var"#s179"<:Tuple{Type}, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##4#PreconditionerData##5"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real, Nothing, Nothing}, sparams=svec(T<:Real, Int64), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, I, I, Bool, Bool, Any, Any, Any) where {T, I<:Integer}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), LinearOperators.ConjugateLinearOperator{T, S} where S where T, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d2182c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), LinearOperators.ConjugateLinearOperator{T, S} where S where T, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{var"#s179", var"#s179", typeof(Base.identity), var"#s179"} where var"#s179"<:Tuple{AbstractArray{Float64, 1}} where var"#s179"<:Tuple where var"#s179"<:Base.Broadcast.BroadcastStyle}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._getindex), Base.IndexLinear, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(-)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Ti, 1} where Ti<:Integer), Int64}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742272c00920)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._getindex), Base.IndexLinear, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(-)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Ti, 1} where Ti<:Integer), Int64}, Int64}, sparams=svec(), method=_getindex(Base.IndexStyle, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000487e, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#view##0#view##1"{Array{T, 1}} where T<:Real, Base.UnitRange{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742287ffc260)[Core.MethodMatch(spec_types=Tuple{Base.var"#view##0#view##1"{Array{T, 1}} where T<:Real, Base.UnitRange{Int64}}, sparams=svec(), method=(::Base.var"#view##0#view##1"{A})(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002dd5, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.map), Base.Fix{1, typeof(Base.to_index), Array{Int64, 1}}, Tuple{Vararg{Int64, N}} where N}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{CodecZlib.var"##GzipCompressor#1", Int32, Int32, Type{CodecZlib.GzipCompressor}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228c113de0)[Core.MethodMatch(spec_types=Tuple{CodecZlib.var"##GzipCompressor#1", Int32, Int32, Type{CodecZlib.GzipCompressor}}, sparams=svec(), method=var"#GzipCompressor#1"(Integer, Integer, Type{CodecZlib.GzipCompressor}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000974a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.methods), RipQP.var"#PreconditionerData##4#PreconditionerData##5"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}, Type{Tuple}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e14eba0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.methods), RipQP.var"#PreconditionerData##4#PreconditionerData##5"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}, Type{Tuple}, Nothing}, sparams=svec(), method=methods(Any, Any, Union{Nothing, Base.AbstractSet{Module}, Tuple{Module}, AbstractArray{Module, N} where N}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000576, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), Array{_A, 1} where _A, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.real), var"#s179"} where var"#s179"<:Tuple{Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64}}}, limit=1), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226ed5d2a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.copyto!), Array{_A, 1} where _A, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.real), var"#s179"} where var"#s179"<:Tuple{Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64}}}, sparams=svec(), method=copyto!(AbstractArray{T, N} where N where T, Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048c4, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R<:Real, Array{R, 1} where R<:Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226ea6f160)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R<:Real, Array{R, 1} where R<:Real}}, sparams=svec(), method=instantiate(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004803, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Nothing, typeof(Base.abs), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228f6984c0)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Nothing, typeof(Base.abs), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Tuple}, sparams=svec(typeof(Base.abs)), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._broadcast_getindex_eltype), FillArrays.AbstractZeros{T, 1, Axes} where Axes where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228b108ac0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._broadcast_getindex_eltype), FillArrays.AbstractZeros{T, 1, Axes} where Axes where T<:Real}, sparams=svec(), method=_broadcast_getindex_eltype(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048a7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.length), Tuple{Union{Char, String, Symbol}, String, String, String, Union{Char, String, Symbol}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273b28e20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.length), Tuple{Union{Char, String, Symbol}, String, String, String, Union{Char, String, Symbol}}}, sparams=svec(), method=length(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000664, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.signature_type), RipQP.var"#PreconditionerData##6#PreconditionerData##7"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}, Type{Tuple}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e50ff20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.signature_type), RipQP.var"#PreconditionerData##6#PreconditionerData##7"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}, Type{Tuple}}, sparams=svec(), method=signature_type(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000546, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.dict_with_eltype), Base.var"#Dict##0#Dict##1", Base.Generator{Base.Set{Symbol}, JSOSolvers.var"#95#96"{Base.Dict{Symbol, Union{}}}}, Type{Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226ef026e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.dict_with_eltype), Base.var"#Dict##0#Dict##1", Base.Generator{Base.Set{Symbol}, JSOSolvers.var"#95#96"{Base.Dict{Symbol, Union{}}}}, Type{Any}}, sparams=svec(Base.var"#Dict##0#Dict##1"), method=dict_with_eltype(F, Base.Generator{I, F} where F where I, Any) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000178b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), RipQP.K2KrylovParams{Float64, PT, FT} where FT<:typeof(DataType) where PT<:(RipQP.LDL{FloatType, F} where F<:RipQP.AbstractFactorization where FloatType<:typeof(DataType)), Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422aa46ba60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), RipQP.K2KrylovParams{Float64, PT, FT} where FT<:typeof(DataType) where PT<:(RipQP.LDL{FloatType, F} where F<:RipQP.AbstractFactorization where FloatType<:typeof(DataType)), Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.convert_QM), QuadraticModels.QuadraticModel{T, S, M1, M2} where M2 where M1 where S<:AbstractArray{T, 1} where T<:Real, Bool, Bool, RipQP.K2LDLParams{_A, RipQP.LDLFact} where _A, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422aa38a6a0)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.convert_QM), QuadraticModels.QuadraticModel{T, S, M1, M2} where M2 where M1 where S<:AbstractArray{T, 1} where T<:Real, Bool, Bool, RipQP.K2LDLParams{_A, RipQP.LDLFact} where _A, Bool}, sparams=svec(T<:Real, S<:AbstractArray{T<:Real, 1}, M1, M2), method=convert_QM(QuadraticModels.QuadraticModel{T, S, M1, M2}, Bool, Bool, RipQP.SolverParams{T} where T, Bool) where {T, S, M1, M2}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), AbstractArray{Float64, 1}, FillArrays.Fill{T, N, Axes} where Axes where N where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228db15460)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), AbstractArray{Float64, 1}, FillArrays.Fill{T, N, Axes} where Axes where N where T}, sparams=svec(), method=materialize!(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048bd, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._push!), Array{ReverseDiff.AbstractInstruction, 1}, ReverseDiff.SpecialInstruction{typeof(Base.fill), I, O, Tuple{ReverseDiff.var"#24#25"{Tuple{Int64}}, ReverseDiff.var"##fill#277#23", NamedTuple{(), Tuple{}}}} where O<:(ReverseDiff.TrackedArray{V, _A, 1, VA, DA} where DA<:(Array{T, 1} where T) where VA<:(ReverseDiff.TrackedArray{V, D, N, VA, DA} where V where D where N where VA where DA) where _A where V<:(ReverseDiff.TrackedReal{V, D, ReverseDiff.TrackedArray{V, D, 1, VA, DA}} where V<:Real where D<:Real where VA<:(Array{T, 1} where T<:Real) where DA<:(Array{T, 1} where T<:Real))) where I<:Tuple{Real, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a7409240)[Core.MethodMatch(spec_types=Tuple{typeof(Base._push!), Array{ReverseDiff.AbstractInstruction, 1}, ReverseDiff.SpecialInstruction{typeof(Base.fill), I, O, Tuple{ReverseDiff.var"#24#25"{Tuple{Int64}}, ReverseDiff.var"##fill#277#23", NamedTuple{(), Tuple{}}}} where O<:(ReverseDiff.TrackedArray{V, _A, 1, VA, DA} where DA<:(Array{T, 1} where T) where VA<:(ReverseDiff.TrackedArray{V, D, N, VA, DA} where V where D where N where VA where DA) where _A where V<:(ReverseDiff.TrackedReal{V, D, ReverseDiff.TrackedArray{V, D, 1, VA, DA}} where V<:Real where D<:Real where VA<:(Array{T, 1} where T<:Real) where DA<:(Array{T, 1} where T<:Real))) where I<:Tuple{Real, Int64}}, sparams=svec(ReverseDiff.AbstractInstruction), method=_push!(Array{T, 1}, T) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000113c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseArrays.rowvals), SparseMatrixColorings.SparsityPatternCSC{Ti} where Ti<:Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a7adc240)[Core.MethodMatch(spec_types=Tuple{typeof(SparseArrays.rowvals), SparseMatrixColorings.SparsityPatternCSC{Ti} where Ti<:Integer}, sparams=svec(), method=rowvals(SparseMatrixColorings.SparsityPatternCSC{Ti} where Ti<:Integer), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009689, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SolverCore.solve!), Union{RipQP.RipQPMonoSolver{T, _A, Int64, _B, _C, Float64, _D, _E} where _E<:(RipQP.PreallocatedFloatData{T, _A, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T, _A} where Dda<:RipQP.DescentDirectionAllocs{T, _A} where Res<:RipQP.AbstractResiduals{T, _A}) where _D<:(RipQP.Abstract_QM_FloatData{T, _A, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where _C<:RipQP.ScaleData{T, _A} where _B<:QuadraticModels.AbstractQuadraticModel{T, _A} where _A, RipQP.RipQPMonoSolver{T, S, Int64, _B, _C, Float64, _D, _E} where _E<:(RipQP.PreallocatedFloatData{T, S, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T, S} where Dda<:RipQP.DescentDirectionAllocs{T, S} where Res<:RipQP.AbstractResiduals{T, S}) where _D<:(RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where _C<:RipQP.ScaleData{T, S} where _B<:QuadraticModels.AbstractQuadraticModel{T, S} where S} where T<:Real, QuadraticModels.QuadraticModel{T, S, M1, M2} where M2 where M1 where S where T, SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T, RipQP.RipQPMonoParameters{T, _A, RipQP.PC} where _A<:RipQP.SolverParams{T} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228dad79a0)[Core.MethodMatch(spec_types=Tuple{typeof(SolverCore.solve!), RipQP.RipQPMonoSolver{T, S, Int64, _B, _C, Float64, _D, _E} where _E<:(RipQP.PreallocatedFloatData{T, S, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T, S} where Dda<:RipQP.DescentDirectionAllocs{T, S} where Res<:RipQP.AbstractResiduals{T, S}) where _D<:(RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where _C<:RipQP.ScaleData{T, S} where _B<:QuadraticModels.AbstractQuadraticModel{T, S}, QuadraticModels.QuadraticModel{T, S, M1, M2} where M2 where M1, SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V, RipQP.RipQPMonoParameters{T, _A, RipQP.PC} where _A<:RipQP.SolverParams{T}} where S where T<:Real, sparams=svec(T<:Real, S), method=solve!(RipQP.RipQPMonoSolver{T, S, I, QMType, Sd, Tsc, QMfd, Pfd} where Pfd<:(RipQP.PreallocatedFloatData{T, S, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T, S} where Dda<:RipQP.DescentDirectionAllocs{T, S} where Res<:RipQP.AbstractResiduals{T, S}) where QMfd<:(RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where Tsc<:Real where Sd<:RipQP.ScaleData{T, S} where QMType<:QuadraticModels.AbstractQuadraticModel{T, S} where I, QuadraticModels.AbstractQuadraticModel{T, S}, SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V, RipQP.RipQPMonoParameters{T, SP1, SM1} where SM1<:RipQP.SolveMethod where SP1<:RipQP.SolverParams{T}) where {T, S}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.cmp), Any, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{Type{ReverseDiff.TrackedStyle}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a77a5020)[Core.MethodMatch(spec_types=Tuple{Type{ReverseDiff.TrackedStyle}}, sparams=svec(), method=(::Type{ReverseDiff.TrackedStyle})(), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.axes), LinearAlgebra.Adjoint{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where Float64<:T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(6, 0x742287c578b0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.axes), LinearAlgebra.Adjoint{T, var"#s179"} where var"#s179"<:(StaticArraysCore.StaticArray{Tuple{var"#s2"}, T, 1} where var"#s2") where Float64<:T<:Real}, sparams=svec(), method=axes(Union{LinearAlgebra.Adjoint{T, var"#s5"} where var"#s5"<:Union{StaticArraysCore.StaticArray{Tuple{var"#s2"}, T, 1} where var"#s2", StaticArraysCore.StaticArray{Tuple{var"#s3", var"#s4"}, T, 2} where var"#s4" where var"#s3"}, LinearAlgebra.Diagonal{T, var"#s12"} where var"#s12"<:(StaticArraysCore.StaticArray{Tuple{var"#s13"}, T, 1} where var"#s13"), LinearAlgebra.Hermitian{T, var"#s9"} where var"#s9"<:(StaticArraysCore.StaticArray{Tuple{var"#s10", var"#s11"}, T, 2} where var"#s11" where var"#s10"), LinearAlgebra.LowerTriangular{T, var"#s17"} where var"#s17"<:(StaticArraysCore.StaticArray{Tuple{var"#s18", var"#s19"}, T, 2} where var"#s19" where var"#s18"), LinearAlgebra.Symmetric{T, var"#s6"} where var"#s6"<:(StaticArraysCore.StaticArray{Tuple{var"#s7", var"#s8"}, T, 2} where var"#s8" where var"#s7"), LinearAlgebra.Transpose{T, var"#s1"} where var"#s1"<:Union{StaticArraysCore.StaticArray{Tuple{var"#s2"}, T, 1} where var"#s2", StaticArraysCore.StaticArray{Tuple{var"#s3", var"#s4"}, T, 2} where var"#s4" where var"#s3"}, LinearAlgebra.UnitLowerTriangular{T, var"#s23"} where var"#s23"<:(StaticArraysCore.StaticArray{Tuple{var"#s24", var"#s25"}, T, 2} where var"#s25" where var"#s24"), LinearAlgebra.UnitUpperTriangular{T, var"#s20"} where var"#s20"<:(StaticArraysCore.StaticArray{Tuple{var"#s21", var"#s22"}, T, 2} where var"#s22" where var"#s21"), LinearAlgebra.UpperTriangular{T, var"#s14"} where var"#s14"<:(StaticArraysCore.StaticArray{Tuple{var"#s15", var"#s16"}, T, 2} where var"#s16" where var"#s15"), StaticArraysCore.StaticArray{Tuple{var"#s25"}, T, 1} where var"#s25", StaticArraysCore.StaticArray{Tuple{var"#s4", var"#s3"}, T, 2} where var"#s3" where var"#s4", StaticArraysCore.StaticArray{var"#s25", T, N} where N where var"#s25"<:Tuple} where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.axes), LinearAlgebra.Adjoint{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where Float64<:T<:Real}, sparams=svec(), method=axes(Union{LinearAlgebra.Adjoint{T, V}, LinearAlgebra.Transpose{T, V}} where V<:(AbstractArray{T, 1} where 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.Broadcast.preprocess), Base.BitArray{1}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(-)), var"#s179"} where var"#s179"<:Tuple{Array{Ti, 1} where Ti<:Integer, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422740064e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.preprocess), Base.BitArray{1}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(-)), var"#s179"} where var"#s179"<:Tuple{Array{Ti, 1} where Ti<:Integer, Int64}}, sparams=svec(), method=preprocess(Any, Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048ca, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{RipQP.LDLData{T, Array{T, 1}, Tlow, RipQP.LRPrecond{Op1, Op2}, _A, var"#s179"}} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real where _A where Op2 where Op1 where Tlow<:Real where T<:Real where T<:Real, Any, RipQP.Regularization{T} where T<:Real, RipQP.FactorizationData{Tlow} where Tlow<:Real, Any, Any, Bool, Bool, LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, S} where S where F where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273bef960)[Core.MethodMatch(spec_types=Tuple{Type{RipQP.LDLData{T, Array{T, 1}, Tlow, RipQP.LRPrecond{Op1, Op2}, _A, var"#s179"}} where var"#s179"<:RipQP.FactorizationData{Tlow} where _A<:Union{AbstractArray{T, 2}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where Op2 where Op1 where Tlow<:Real where T<:Real where T<:Real, Any, RipQP.Regularization{T} where T<:Real, RipQP.FactorizationData{Tlow} where Tlow<:Real, Any, Any, Bool, Bool, LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, S} where S where F where T}, sparams=svec(), method=(::Type{RipQP.LDLData{T<:Real, S, Tlow, Op<:Union{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T, RipQP.LRPrecond{Op1, Op2} where Op2 where Op1}, M<:Union{AbstractArray{T<:Real, 2}, LinearOperators.LinearOperator{T<:Real, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, F<:RipQP.FactorizationData{Tlow}}})(Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.has_offset_axes), SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7422894d8aa0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.has_offset_axes), SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv}, sparams=svec(), method=has_offset_axes(Any), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000122f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(var"==")), Integer, Int64}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._indices_sub), Vararg{Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x742284679120)[ Core.MethodMatch(spec_types=Tuple{typeof(Base._indices_sub)}, sparams=svec(), method=_indices_sub(), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base._indices_sub), AbstractArray{T, N} where N where T, Vararg{Any}}, sparams=svec(), method=_indices_sub(AbstractArray{T, N} where N where T, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base._indices_sub), Real, Vararg{Any}}, sparams=svec(), method=_indices_sub(Real, Any...), fully_covers=false), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002e41, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isbits), LinearAlgebra.Diagonal{T, V} where V<:Array{T, 1} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228f791ce0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.isbits), LinearAlgebra.Diagonal{T, V} where V<:Array{T, 1} where T<:Real}, sparams=svec(), method=isbits(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000505, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.compute_μ), Any, Any, AbstractArray{Float64, 1}, AbstractArray{Float64, 1}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422840986a0)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.compute_μ), Any, Any, AbstractArray{Float64, 1}, AbstractArray{Float64, 1}, Int64, Int64}, sparams=svec(), method=compute_μ(Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SolverCore.set_iter!), SolverCore.GenericExecutionStats{T, V, V, Tsp} where Tsp where V where V<:AbstractArray{T, 1} where T, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a92336c0)[Core.MethodMatch(spec_types=Tuple{typeof(SolverCore.set_iter!), SolverCore.GenericExecutionStats{T, V, V, Tsp} where Tsp where V where V<:AbstractArray{T, 1} where T, Int64}, sparams=svec(), method=set_iter!(SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096bd, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.length), Type{SA} where SA<:(StaticArraysCore.StaticArray{S, T, N} where N where T where S<:Tuple)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7422855c7d20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.length), Type{SA} where SA<:(StaticArraysCore.StaticArray{S, T, N} where N where T where S<:Tuple)}, sparams=svec(SA<:(StaticArraysCore.StaticArray{S, T, N} where N where T where S<:Tuple)), method=length(Type{SA}) where {SA<:(Union{LinearAlgebra.Adjoint{T, var"#s5"} where var"#s5"<:Union{StaticArraysCore.StaticArray{Tuple{var"#s2"}, T, 1} where var"#s2", StaticArraysCore.StaticArray{Tuple{var"#s3", var"#s4"}, T, 2} where var"#s4" where var"#s3"}, LinearAlgebra.Diagonal{T, var"#s12"} where var"#s12"<:(StaticArraysCore.StaticArray{Tuple{var"#s13"}, T, 1} where var"#s13"), LinearAlgebra.Hermitian{T, var"#s9"} where var"#s9"<:(StaticArraysCore.StaticArray{Tuple{var"#s10", var"#s11"}, T, 2} where var"#s11" where var"#s10"), LinearAlgebra.LowerTriangular{T, var"#s17"} where var"#s17"<:(StaticArraysCore.StaticArray{Tuple{var"#s18", var"#s19"}, T, 2} where var"#s19" where var"#s18"), LinearAlgebra.Symmetric{T, var"#s6"} where var"#s6"<:(StaticArraysCore.StaticArray{Tuple{var"#s7", var"#s8"}, T, 2} where var"#s8" where var"#s7"), LinearAlgebra.Transpose{T, var"#s1"} where var"#s1"<:Union{StaticArraysCore.StaticArray{Tuple{var"#s2"}, T, 1} where var"#s2", StaticArraysCore.StaticArray{Tuple{var"#s3", var"#s4"}, T, 2} where var"#s4" where var"#s3"}, LinearAlgebra.UnitLowerTriangular{T, var"#s23"} where var"#s23"<:(StaticArraysCore.StaticArray{Tuple{var"#s24", var"#s25"}, T, 2} where var"#s25" where var"#s24"), LinearAlgebra.UnitUpperTriangular{T, var"#s20"} where var"#s20"<:(StaticArraysCore.StaticArray{Tuple{var"#s21", var"#s22"}, T, 2} where var"#s22" where var"#s21"), LinearAlgebra.UpperTriangular{T, var"#s14"} where var"#s14"<:(StaticArraysCore.StaticArray{Tuple{var"#s15", var"#s16"}, T, 2} where var"#s16" where var"#s15"), StaticArraysCore.StaticArray{Tuple{var"#s25"}, T, 1} where var"#s25", StaticArraysCore.StaticArray{Tuple{var"#s4", var"#s3"}, T, 2} where var"#s3" where var"#s4", StaticArraysCore.StaticArray{var"#s25", T, N} where N where var"#s25"<:Tuple} where T)}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000969d, max_world=0xffffffffffffffff), ambig=true), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.rewrap_unionall), Any, Type{var"#s179"} where var"#s179"<:Tuple{Pair{Symbol, QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2}} where M2 where M1 where S where T, Pair{Symbol, Array{QuadraticModels.PresolveOperation{T, _A}, 1}} where _A where T<:Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226ee54320)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.rewrap_unionall), Core.TypeofVararg, Type{var"#s179"} where var"#s179"<:Tuple{Pair{Symbol, QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2}} where M2 where M1 where S where T, Pair{Symbol, Array{QuadraticModels.PresolveOperation{T, _A}, 1}} where _A where T<:Real}}, sparams=svec(), method=rewrap_unionall(Core.TypeofVararg, Any), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.rewrap_unionall), Any, Type{var"#s179"} where var"#s179"<:Tuple{Pair{Symbol, QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2}} where M2 where M1 where S where T, Pair{Symbol, Array{QuadraticModels.PresolveOperation{T, _A}, 1}} where _A where T<:Real}}, sparams=svec(), method=rewrap_unionall(Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000363, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:(LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, S} where S where F where T), LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, S} where S where F where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226e5b36e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, S} where S where F where T}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, S} where S where F where T} where T<:(LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, S} where S where F where T), sparams=svec(T), method=convert(Type{T}, T) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000034c, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IndexStyle}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(*)), var"#s179"} where var"#s179"<:Tuple{Int64, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422717b1320)[Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(*)), var"#s179"} where var"#s179"<:Tuple{Int64, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}}, sparams=svec(), method=(::Type{Base.IndexStyle})(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047e9, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto_unaliased!), Base.IndexLinear, Base.SubArray{_A, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{_A, 1} where _A) where _A, Base.IndexLinear, Array{Base.Rational{Int64}, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a95f8f00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.copyto_unaliased!), Base.IndexLinear, Base.SubArray{_A, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{_A, 1} where _A) where _A, Base.IndexLinear, Array{Base.Rational{Int64}, 1}}, sparams=svec(), method=copyto_unaliased!(Base.IndexStyle, AbstractArray{T, N} where N where T, Base.IndexStyle, AbstractArray{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012ae, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{T, var"#s179"} where var"#s179"<:Tuple where T, Base.Val{x} where x}, limit=5), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(5,), mem=Memory{Any}(6, 0x7422a70b8160)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{T, var"#s179"} where var"#s179"<:Tuple where T, Base.Val{3}}, sparams=svec(), method=ntuple(Any, Base.Val{3}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{T, var"#s179"} where var"#s179"<:Tuple where T, Base.Val{2}}, sparams=svec(), method=ntuple(Any, Base.Val{2}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{T, var"#s179"} where var"#s179"<:Tuple where T, Base.Val{1}}, sparams=svec(), method=ntuple(Any, Base.Val{1}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{T, var"#s179"} where var"#s179"<:Tuple where T, Base.Val{0}}, sparams=svec(), method=ntuple(Any, Base.Val{0}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{T, var"#s179"} where var"#s179"<:Tuple where T, Base.Val{x} where x}, sparams=svec(F<:(Base.var"#cvt1#convert##0"{T, var"#s179"} where var"#s179"<:Tuple where T), x), method=ntuple(F, Base.Val{N}) where {F, N}, fully_covers=true), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000017e3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.real), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64})}, Type{AbstractFloat}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228ea848a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.real), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64})}, Type{AbstractFloat}, Tuple{Base.OneTo{Int64}}}, sparams=svec(1, AbstractFloat), method=similar(Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{N}, Axes, F, Args} where Args<:Tuple where F where Axes, Type{ElType}, Any) where {N, ElType}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047d4, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.convertpad), Type{RipQP.PreallocatedData{T, S} where S} where T<:Real, RipQP.PreallocatedDataK2LDL{T_old, _A, F, _B} where _B<:AbstractArray{T_old, 2} where F<:(RipQP.LDLFactorizationData{T} where T) where _A where T_old<:Real, RipQP.SolverParams{T} where T, RipQP.SolverParams{T} where T<:Real, RipQP.QM_IntData, RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226eb15ba0)[ Core.MethodMatch(spec_types=Tuple{typeof(RipQP.convertpad), Type{RipQP.PreallocatedData{T, S} where S}, RipQP.PreallocatedDataK2LDL{T_old, _A, F, _B} where _B<:AbstractArray{T_old, 2} where F<:(RipQP.LDLFactorizationData{T} where T) where _A, RipQP.K2LDLParams{T, Fact} where Fact where T, RipQP.K2LDLParams{T, Fact} where Fact where T<:Real, RipQP.QM_IntData, RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S where T<:Real} where T_old<:Real where T<:Real, sparams=svec(T<:Real, T_old<:Real), method=convertpad(Type{var"#s44"} where var"#s44"<:(RipQP.PreallocatedData{T, S} where S), RipQP.PreallocatedDataK2LDL{T_old, S, F, M} where M<:AbstractArray{T_old, 2} where F where S, RipQP.K2LDLParams{T, Fact} where Fact where T, RipQP.K2LDLParams{T, Fact} where Fact where T, RipQP.QM_IntData, RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S where T<:Real) where {T<:Real, T_old<:Real}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(RipQP.convertpad), Type{RipQP.PreallocatedData{T, S} where S}, RipQP.PreallocatedDataK2LDL{T_old, _A, F, _B} where _B<:AbstractArray{T_old, 2} where F<:(RipQP.LDLFactorizationData{T} where T) where _A, RipQP.K2LDLParams{T, Fact} where Fact where T, RipQP.K2KrylovParams{T, PT, FT} where FT<:typeof(DataType) where PT where T<:Real, RipQP.QM_IntData, RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S where T<:Real} where T_old<:Real where T<:Real, sparams=svec(T<:Real, T_old<:Real), method=convertpad(Type{var"#s44"} where var"#s44"<:(RipQP.PreallocatedData{T, S} where S), RipQP.PreallocatedDataK2LDL{T_old, S, F, M} where M<:AbstractArray{T_old, 2} where F where S, RipQP.K2LDLParams{T, Fact} where Fact where T, RipQP.K2KrylovParams{T, PT, FT} where FT<:typeof(DataType) where PT where T, RipQP.QM_IntData, RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S where T<:Real) where {T<:Real, T_old<:Real}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(<)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.abs), Tuple{Base.Broadcast.Extruded{Array{Float64, 1}, Tuple{Bool}, Tuple{Int64}}}}, Float64}}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228911c880)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(<)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.abs), Tuple{Base.Broadcast.Extruded{Array{Float64, 1}, Tuple{Bool}, Tuple{Int64}}}}, Float64}}, 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.unsafe_view), Array{var"#s4711", 1} where var"#s4711"<:Float64, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228dfa5bc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_view), Array{var"#s4711", 1} where var"#s4711"<:Float64, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(1), method=unsafe_view(AbstractArray{T, N} where N where T, Vararg{Union{Real, AbstractArray{T, N} where N where T}, N}) where {N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002dde, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core._typeof_captured_variable), Tuple{AbstractArray{T, 1} where T<:Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742282e7a4c0)[Core.MethodMatch(spec_types=Tuple{typeof(Core._typeof_captured_variable), Tuple{AbstractArray{T, 1} where T<:Real}}, sparams=svec(), method=_typeof_captured_variable(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000004a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.Generator{I, typeof(Base.identity)} where I<:(Base.SubArray{Any, 1, P, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, false} where P<:(Array{T, 1} where T<:Real)), Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226f6ce2a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.Generator{I, typeof(Base.identity)} where I<:(Base.SubArray{Any, 1, P, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, false} where P<:(Array{T, 1} where T<:Real)), Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.merge_fallback), NamedTuple{(:ap,), var"#s179"} where var"#s179"<:Tuple{RipQP.RipQPTripleParameters{T, SP1, SP2, _A, RipQP.PC, RipQP.PC, RipQP.PC} where _A<:RipQP.SolverParams{T} where SP2<:(RipQP.SolverParams{T} where T) where SP1<:(RipQP.K2LDLParams{_A, RipQP.LDLFact} where _A) where T<:Real}, NamedTuple{names, T} where T<:Tuple{Vararg{Any, N}} where names where N, Tuple{Symbol}, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228caba9a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.merge_fallback), NamedTuple{(:ap,), var"#s179"} where var"#s179"<:Tuple{RipQP.RipQPTripleParameters{T, SP1, SP2, _A, RipQP.PC, RipQP.PC, RipQP.PC} where _A<:RipQP.SolverParams{T} where SP2<:(RipQP.SolverParams{T} where T) where SP1<:(RipQP.K2LDLParams{_A, RipQP.LDLFact} where _A) where T<:Real}, NamedTuple{names, T} where T<:Tuple{Vararg{Any, N}} where names where N, Tuple{Symbol}, Tuple{Vararg{Symbol}}}, sparams=svec(), method=merge_fallback(NamedTuple{names, T} where T<:Tuple where names, NamedTuple{names, T} where T<:Tuple where names, Tuple{Vararg{Symbol}}, Tuple{Vararg{Symbol}}), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001a99, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.:(<=)), Tuple{Array{R, 1} where R, Array{R, 1} where R}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228a6f3d40)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.:(<=)), Tuple{Array{R, 1} where R, Array{R, 1} where R}, Tuple{Base.OneTo{Int64}}}, sparams=svec(typeof(Base.:(<=))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), QuadraticModels.QMSolution{S, V} where V where S, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228329b460)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), QuadraticModels.QMSolution{S, V} where V where S, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), Any, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, _A, typeof(Base.identity), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R} where _A}, limit=1), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{Type{ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T}, NLPModels.NLPModelMeta{Float64, Array{Float64, 1}}, NLPModels.Counters, ADNLPModels.ADModelBackend{_A, _B, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, _C, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend} where _C where _B where _A, SolverTest.var"#18#19"{LinearAlgebra.Diagonal{Base.Rational{Int64}, Array{Base.Rational{Int64}, 1}}}, ADNLPModels.var"#297#298"{Type{Float64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228cf82b60)[Core.MethodMatch(spec_types=Tuple{Type{ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T}, NLPModels.NLPModelMeta{Float64, Array{Float64, 1}}, NLPModels.Counters, ADNLPModels.ADModelBackend{_A, _B, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, _C, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend} where _C where _B where _A, SolverTest.var"#18#19"{LinearAlgebra.Diagonal{Base.Rational{Int64}, Array{Base.Rational{Int64}, 1}}}, ADNLPModels.var"#297#298"{Type{Float64}}}, sparams=svec(Float64, Array{Float64, 1}), method=(::Type{ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T})(NLPModels.NLPModelMeta{T, S}, NLPModels.Counters, ADNLPModels.ADModelBackend{GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS} where HBLS where JBLS where JtvBLS where JvBLS where HvBLS where GHJ where HB where JB where JtvB where JvB where HvB where GB, Any, Any) where {T, S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096b3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SolverCore.solve!), Union{RipQP.RipQPDoubleSolver{T, _A, Int64, _B, _C, Float64, T1, _D, _E, _F, _G} where _G<:(RipQP.PreallocatedFloatData{T1, _D, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T1, _D} where Dda<:RipQP.DescentDirectionAllocs{T1, _D} where Res<:RipQP.AbstractResiduals{T1, _D}) where _F<:(RipQP.Abstract_QM_FloatData{T, _A, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where _E<:(RipQP.Abstract_QM_FloatData{T1, _D, M1, M2} where M2<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}} where M1<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}}) where _D where T1<:Real where _C<:RipQP.ScaleData{T, _A} where _B<:QuadraticModels.AbstractQuadraticModel{T, _A} where _A, RipQP.RipQPDoubleSolver{T, _A, Int64, _B, _C, Float64, T1, S1, _E, _F, _G} where _G<:(RipQP.PreallocatedFloatData{T1, S1, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T1, S1} where Dda<:RipQP.DescentDirectionAllocs{T1, S1} where Res<:RipQP.AbstractResiduals{T1, S1}) where _F<:(RipQP.Abstract_QM_FloatData{T, _A, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where _E<:(RipQP.Abstract_QM_FloatData{T1, S1, M1, M2} where M2<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}} where M1<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}}) where S1 where T1<:Real where _C<:RipQP.ScaleData{T, _A} where _B<:QuadraticModels.AbstractQuadraticModel{T, _A} where _A, RipQP.RipQPDoubleSolver{T, S, Int64, _B, _C, Float64, T1, _D, _E, _F, _G} where _G<:(RipQP.PreallocatedFloatData{T1, _D, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T1, _D} where Dda<:RipQP.DescentDirectionAllocs{T1, _D} where Res<:RipQP.AbstractResiduals{T1, _D}) where _F<:(RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where _E<:(RipQP.Abstract_QM_FloatData{T1, _D, M1, M2} where M2<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}} where M1<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}}) where _D where T1<:Real where _C<:RipQP.ScaleData{T, S} where _B<:QuadraticModels.AbstractQuadraticModel{T, S} where S, RipQP.RipQPDoubleSolver{T, S, Int64, _B, _C, Float64, T1, S1, _E, _F, _G} where _G<:(RipQP.PreallocatedFloatData{T1, S1, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T1, S1} where Dda<:RipQP.DescentDirectionAllocs{T1, S1} where Res<:RipQP.AbstractResiduals{T1, S1}) where _F<:(RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where _E<:(RipQP.Abstract_QM_FloatData{T1, S1, M1, M2} where M2<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}} where M1<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}}) where S1 where T1<:Real where _C<:RipQP.ScaleData{T, S} where _B<:QuadraticModels.AbstractQuadraticModel{T, S} where S} where T<:Real, QuadraticModels.AbstractQuadraticModel{T, S} where S where T<:Real, SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T, RipQP.RipQPDoubleParameters{T, SP1, _A, RipQP.PC, RipQP.PC} where _A<:RipQP.SolverParams{T} where SP1<:(RipQP.K2LDLParams{_A, RipQP.LDLFact} where _A) where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d803ea0)[Core.MethodMatch(spec_types=Tuple{typeof(SolverCore.solve!), RipQP.RipQPDoubleSolver{T, S, Int64, _B, _C, Float64, T1, S1, _E, _F, _G} where _G<:(RipQP.PreallocatedFloatData{T1, S1, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T1, S1} where Dda<:RipQP.DescentDirectionAllocs{T1, S1} where Res<:RipQP.AbstractResiduals{T1, S1}) where _F<:(RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where _E<:(RipQP.Abstract_QM_FloatData{T1, S1, M1, M2} where M2<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}} where M1<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}}) where S1 where T1<:Real where _C<:RipQP.ScaleData{T, S} where _B<:QuadraticModels.AbstractQuadraticModel{T, S}, QuadraticModels.AbstractQuadraticModel{T, S}, SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V, RipQP.RipQPDoubleParameters{T, SP1, _A, RipQP.PC, RipQP.PC} where _A<:RipQP.SolverParams{T} where SP1<:(RipQP.K2LDLParams{_A, RipQP.LDLFact} where _A) where T<:Real} where S where T<:Real, sparams=svec(T<:Real, S), method=solve!(RipQP.RipQPDoubleSolver{T, S, I, QMType, Sd, Tsc, T1, S1, QMfd1, QMfd2, Pfd} where Pfd<:(RipQP.PreallocatedFloatData{T1, S1, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T1, S1} where Dda<:RipQP.DescentDirectionAllocs{T1, S1} where Res<:RipQP.AbstractResiduals{T1, S1}) where QMfd2<:(RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where QMfd1<:(RipQP.Abstract_QM_FloatData{T1, S1, M1, M2} where M2<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}} where M1<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}}) where S1 where T1 where Tsc<:Real where Sd<:RipQP.ScaleData{T, S} where QMType<:QuadraticModels.AbstractQuadraticModel{T, S} where I, QuadraticModels.AbstractQuadraticModel{T, S}, SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V, RipQP.RipQPDoubleParameters{T, SP1, SP2, SM1, SM2} where SM2<:RipQP.SolveMethod where SM1<:RipQP.SolveMethod where SP2<:RipQP.SolverParams{T} where SP1<:(RipQP.SolverParams{T} where T) where T<:Real) where {T, S}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Base.Iterators.Zip{Is} where Is<:Tuple{Any, Any}, Tuple{Any, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742272473280)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Base.Iterators.Zip{Is} where Is<:Tuple{Any, Any}, Tuple{Any, Any}}, sparams=svec(), method=iterate(Base.Iterators.Zip{Is} where Is<:Tuple, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000018c2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unwrapva), Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a9cfcca0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unwrapva), Any}, sparams=svec(), method=unwrapva(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000036d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.dotgetproperty), ADNLPModels.SparseADJacobian{Tag, R, T, C, S} where S where C where T where R where Tag, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a897c500)[Core.MethodMatch(spec_types=Tuple{typeof(Base.dotgetproperty), ADNLPModels.SparseADJacobian{Tag, R, T, C, S} where S where C where T where R where Tag, Symbol}, sparams=svec(), method=dotgetproperty(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000286, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.map), Base.var"#view##0#view##1"{Array{T, 1}} where T<:Real, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isempty), Tuple{String, typeof(DataType), String, Type, String, Type, String, Type, String, typeof(DataType), String, Type, String}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74228a7d2fe0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.isempty), Tuple{String, typeof(DataType), String, Type, String, Type, String, Type, String, typeof(DataType), String, Type, String}}, sparams=svec(), method=isempty(Tuple), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000726, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copy), Array{T, 1} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422aa3af920)[Core.MethodMatch(spec_types=Tuple{typeof(Base.copy), Array{T, 1} where T<:Real}, sparams=svec(), method=copy(Array{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010b0, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.string), Type{var"#s179"} where var"#s179"<:Signed}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742285833d80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.string), Type{var"#s179"} where var"#s179"<:Signed}, sparams=svec(), method=string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003db1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Int8}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742283518500)[Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Int8}, Int64}, sparams=svec(Int8), 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._to_linear_index), Array{T, 1} where T<:Number}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d191da0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._to_linear_index), Array{T, 1} where T<:Number}, sparams=svec(), method=_to_linear_index(AbstractArray{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012e2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{NamedTuple{(:ap,), T} where T<:Tuple}, Tuple{RipQP.RipQPDoubleParameters{T, SP1, _A, RipQP.PC, RipQP.PC} where _A<:RipQP.SolverParams{T} where SP1<:(RipQP.K2LDLParams{_A, RipQP.LDLFact} where _A) where T<:Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422704c9ae0)[Core.MethodMatch(spec_types=Tuple{Type{NamedTuple{(:ap,), T} where T<:Tuple}, Tuple{RipQP.RipQPDoubleParameters{T, SP1, _A, RipQP.PC, RipQP.PC} where _A<:RipQP.SolverParams{T} where SP1<:(RipQP.K2LDLParams{_A, RipQP.LDLFact} where _A) where T<:Real}}, sparams=svec((:ap,)), 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{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Nothing, typeof(SparseMatricesCOO.replace_if_minusinf), Tuple, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742287cf6680)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Nothing, typeof(SparseMatricesCOO.replace_if_minusinf), Tuple, Any}, sparams=svec(typeof(SparseMatricesCOO.replace_if_minusinf)), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), Any, Base.SubArray{Float64, 1, Array{Float64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a95be3e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.Broadcast.BroadcastStyle, Base.SubArray{Float64, 1, Array{Float64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"}, sparams=svec(), method=materialize!(Base.Broadcast.BroadcastStyle, Any, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048bf, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Base.Dict{Symbol, Tsp} where Tsp}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228ca0b0e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Base.Dict{Symbol, Tsp} where Tsp}, sparams=svec(), method=iterate(Base.Dict{K, V} where V where K), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000034f1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), Tuple{Base.RefValue{typeof(Base.:(*))}, AbstractArray{T, N} where N where T, Array{T, N} where N where T}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228c3af1c0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), Tuple{Base.RefValue{typeof(Base.:(*))}, AbstractArray{T, N} where N where T, Array{T, N} where N where T}}, sparams=svec(), method=Typeof(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000028, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{LinearOperators.var"##_#2", Type, Type{LinearOperators.LinearOperator{Tlow, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where Tlow<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##8#PreconditionerData##9"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Nothing, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228aa0c060)[Core.MethodMatch(spec_types=Tuple{LinearOperators.var"##_#2", Type, Type{LinearOperators.LinearOperator{Tlow, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where Tlow<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##8#PreconditionerData##9"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Nothing, Nothing}, sparams=svec(Tlow<:Real, Int64), method=var"#_#2"(Type, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, I, I, Bool, Bool, Any, Any, Any) where {T, I<:Integer}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_result), Type, Type{Tuple{String, typeof(JSOSolvers.fomo)}}, Any, Type{Tuple{String, typeof(JSOSolvers.fomo)}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228ef69d00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_result), Type, Type{Tuple{String, typeof(JSOSolvers.fomo)}}, Type{T}, Type{Tuple{String, typeof(JSOSolvers.fomo)}}} where T, sparams=svec(T, Tuple{String, typeof(JSOSolvers.fomo)}), method=promote_result(Type, Type, Type{T}, Type{S}) where {T, S}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000602, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.BroadcastStyle}, Type{Base.SubArray{Any, 1, P, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, false}} where P<:(Array{T, 1} where T<:Real)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226da937a0)[ Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.BroadcastStyle}, Type{Base.SubArray{Any, 1, P, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, false}} where P<:(Array{T, 1} where T<:Real)}, sparams=svec(Any, 1), method=(::Type{Base.Broadcast.BroadcastStyle})(Type{var"#s677"} where var"#s677"<:AbstractArray{T, N}) where {T, N}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000479b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:Tuple{Base.RefValue{typeof(Base.:(<=))}, Array{T, N} where N where T, Any}, Tuple{Base.RefValue{typeof(Base.:(<=))}, Array{T, N} where N where T, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x74228325eae0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Tuple{Base.RefValue{typeof(Base.:(<=))}, Array{T, N} where N where T, Any}}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, Tuple{Base.RefValue{typeof(Base.:(<=))}, Array{T, N} where N where T, Any}} where T<:Tuple{Base.RefValue{typeof(Base.:(<=))}, Array{T, N} where N where T, Any}, sparams=svec(T<:Tuple), method=convert(Type{T}, T) where {T<:Tuple}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:Tuple{Base.RefValue{typeof(Base.:(<=))}, Array{T, N} where N where T, Any}, Tuple{Base.RefValue{typeof(Base.:(<=))}, Array{T, N} where N where T, Any}}, sparams=svec(3, var"#s175"<:Tuple{Base.RefValue{typeof(Base.:(<=))}, Array{T, N} where N where T, Any}), 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{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, Type{T} where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##4#PreconditionerData##5"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}, Nothing, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e1029a0)[Core.MethodMatch(spec_types=Tuple{Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, Type{T} where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##4#PreconditionerData##5"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}, Nothing, Nothing}, sparams=svec(T<:Real, Int64), method=(::Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T})(Type{T}, I, I, Bool, Bool, Any, Any, Any) where {T, I<:Integer}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{ft} where ft<:(Array{T, 1} where T<:Number), Base.SubArray{T, 1, P, I, L} where L where I where P where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226f3bdb60)[ Core.MethodMatch(spec_types=Tuple{Type{Union{}}, Base.SubArray{T, 1, P, I, L} where L where I where P where T}, sparams=svec(), method=(::Type{Union{}})(Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{Array{T, 1}}, Base.SubArray{S, 1, P, I, L} where L where I where P} where S where T<:Number, sparams=svec(T<:Number, 1, S), method=(::Type{Array{T, N}})(AbstractArray{S, N}) where {T, N, S}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010df, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._any_tuple), Base.var"#TupleOrBottom##0#TupleOrBottom##1", Bool, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74227329bce0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._any_tuple), Base.var"#TupleOrBottom##0#TupleOrBottom##1", Bool, Any}, sparams=svec(), method=_any_tuple(Any, Any, Any, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001ad6, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:x0,), Tuple{Array{Float64, 1}}}, Type{ADNLPModels.ADModelBackend{GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS} where HBLS where JBLS where JtvBLS where JvBLS where HvBLS where GHJ where HB where JB where JtvB where JvB where HvB where GB}, Int64, SolverTest.var"#51#52"{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d5ff9a0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:x0,), Tuple{Array{Float64, 1}}}, Type{ADNLPModels.ADModelBackend{GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS} where HBLS where JBLS where JtvBLS where JvBLS where HvBLS where GHJ where HB where JB where JtvB where JvB where HvB where GB}, Int64, SolverTest.var"#51#52"{Int64}}, sparams=svec(), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, Type{ADNLPModels.ADModelBackend{GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS} where HBLS where JBLS where JtvBLS where JvBLS where HvBLS where GHJ where HB where JB where JtvB where JvB where HvB where GB}, Integer, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096b3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), Any, AbstractArray{T, 1} where T, Base.Broadcast.Broadcasted{var"#s179", Nothing, typeof(Base.identity), var"#s179"} where var"#s179"<:Tuple{AbstractArray{T, 1} where T} where var"#s179"<:Base.Broadcast.BroadcastStyle}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a78c3840)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.Broadcast.BroadcastStyle, AbstractArray{T, 1} where T, Base.Broadcast.Broadcasted{var"#s179", Nothing, typeof(Base.identity), var"#s179"} where var"#s179"<:Tuple{AbstractArray{T, 1} where T} where var"#s179"<:Base.Broadcast.BroadcastStyle}, sparams=svec(), method=materialize!(Base.Broadcast.BroadcastStyle, Any, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048bf, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eltype), Type{Tuple{Bool, Bool, Bool, Symbol}}}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x742286a1be20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.eltype), Type{Tuple{Bool, Bool, Bool, Symbol}}}, sparams=svec(), method=eltype(Type{var"#s179"} where var"#s179"<:Tuple), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006a9, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{LimitedLDLFactorizations.var"##lldl_factorize!#3", Any, typeof(LimitedLDLFactorizations.lldl_factorize!), LimitedLDLFactorizations.LimitedLDLFactorization{T, Ti, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Ti<:Integer where T<:Real, SparseArrays.SparseMatrixCSC{Float64, Ti} where Ti<:Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742283df8ae0)[Core.MethodMatch(spec_types=Tuple{LimitedLDLFactorizations.var"##lldl_factorize!#3", Real, typeof(LimitedLDLFactorizations.lldl_factorize!), LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Ti, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T), SparseArrays.SparseMatrixCSC{Float64, Ti}} where Ti<:Integer where Tf<:Real, sparams=svec(Tf<:Number, Tv<:Number, Ti<:Integer), method=var"#lldl_factorize!#3"(Tf, typeof(LimitedLDLFactorizations.lldl_factorize!), LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Ti, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T), SparseArrays.SparseMatrixCSC{Tv, Ti}) where {Tf<:Number, Tv<:Number, Ti<:Integer}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009769, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_rule), Type{typeof(DataType)}, typeof(DataType)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e7c2e80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_rule), Type{typeof(DataType)}, typeof(DataType)}, 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{typeof(Base.getproperty), Type{RipQP.LDLData{T, S, Tlow, Op, M, F}} where F<:RipQP.FactorizationData{Tlow} where M<:Union{AbstractArray{T, 2}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where Op<:Union{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T, RipQP.LRPrecond{Op1, Op2} where Op2 where Op1} where Tlow where S where T<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273d0d960)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Type{RipQP.LDLData{T, S, Tlow, Op, M, F}} where F<:RipQP.FactorizationData{Tlow} where M<:Union{AbstractArray{T, 2}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where Op<:Union{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T, RipQP.LRPrecond{Op1, Op2} where Op2 where Op1} where Tlow where S where T<:Real, 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.foldl_impl), Base.MappingRF{F, Base.MappingRF{Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}, Base.BottomRF{typeof(Base.add_sum)}}} where F<:(NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLPModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T), Int64, Array{Int64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742289860d80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.foldl_impl), Base.MappingRF{F, Base.MappingRF{Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}, Base.BottomRF{typeof(Base.add_sum)}}} where F<:(NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLPModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T), Int64, Array{Int64, 1}}, sparams=svec(OP<:(Base.MappingRF{F, Base.MappingRF{Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}, Base.BottomRF{typeof(Base.add_sum)}}} where F<:(NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLPModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T))), method=foldl_impl(OP, Any, Any) where {OP}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000031da, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(DiffResults.value), DiffResults.MutableDiffResult{O, V, D} where D<:Tuple where V where O}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422833b4060)[Core.MethodMatch(spec_types=Tuple{typeof(DiffResults.value), DiffResults.MutableDiffResult{O, V, D} where D<:Tuple where V where O}, sparams=svec(), method=value(DiffResults.DiffResult{O, V, D} where D<:Tuple where V where O), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000968d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.in), Memory{T} where T, Base.KeySet{Any, Base.IdDict{Any, Any}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7422864990e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.in), Memory{T} where T, Base.KeySet{Any, Base.IdDict{Any, Any}}}, sparams=svec(), method=in(Any, Base.KeySet{var"#s179", var"#s178"} where var"#s178"<:(Base.IdDict{K, V} where V where K) where var"#s179"), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000017b2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.all), Base.Generator{I, LinearOperators.var"#143#144"} where I<:Tuple{Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T, LinearOperators.LinearOperator{_A, Int64, LinearOperators.var"#119#120", LinearOperators.var"#119#120", LinearOperators.var"#119#120", T} where T where _A}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228ce80e00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.all), Base.Generator{I, LinearOperators.var"#143#144"} where I<:Tuple{Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T, LinearOperators.LinearOperator{_A, Int64, LinearOperators.var"#119#120", LinearOperators.var"#119#120", LinearOperators.var"#119#120", T} where T where _A}}, sparams=svec(), method=all(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001acf, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(-)), var"#s179"} where var"#s179"<:Tuple{Array{Ti, 1} where Ti<:Integer, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74228540c460)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(-)), var"#s179"} where var"#s179"<:Tuple{Array{Ti, 1} where Ti<:Integer, Int64}}, sparams=svec(), method=instantiate(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004803, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.compute_stride1), Array{T, 1} where T<:Real, Tuple{Base.UnitRange{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742285c17960)[Core.MethodMatch(spec_types=Tuple{typeof(Base.compute_stride1), Array{T, 1} where T<:Real, Tuple{Base.UnitRange{Int64}}}, sparams=svec(1), method=compute_stride1(AbstractArray{T, N} where N where T, Tuple{Vararg{Any, N}}) where {N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002e19, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseArrays.LibSuiteSparse.cholmod_copy_factor), SparseArrays.CHOLMOD.Factor{Tv, Int32} where Tv<:Union{Float32, Float64}, Ref{SparseArrays.LibSuiteSparse.cholmod_common_struct}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a759aac0)[Core.MethodMatch(spec_types=Tuple{typeof(SparseArrays.LibSuiteSparse.cholmod_copy_factor), SparseArrays.CHOLMOD.Factor{Tv, Int32} where Tv<:Union{Float32, Float64}, Ref{SparseArrays.LibSuiteSparse.cholmod_common_struct}}, sparams=svec(), method=cholmod_copy_factor(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009675, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._stable_typeof), Array{T, 1} where T<:Number}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d210f80)[Core.MethodMatch(spec_types=Tuple{typeof(Base._stable_typeof), Array{T, 1} where T<:Number}, sparams=svec(), method=_stable_typeof(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c14, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseArrays.LibSuiteSparse.cholmod_l_analyze), SparseArrays.CHOLMOD.Sparse{Tv, Int64} where Tv<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}, Ref{SparseArrays.LibSuiteSparse.cholmod_common_struct}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228ae73380)[Core.MethodMatch(spec_types=Tuple{typeof(SparseArrays.LibSuiteSparse.cholmod_l_analyze), SparseArrays.CHOLMOD.Sparse{Tv, Int64} where Tv<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}, Ref{SparseArrays.LibSuiteSparse.cholmod_common_struct}}, sparams=svec(), method=cholmod_l_analyze(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009675, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Dict{K, V} where V where K}, Pair{Symbol, Nothing}, Pair{Symbol, Array{QuadraticModels.PresolveOperation{Float64, Array{Float64, 1}}, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a91f2000)[Core.MethodMatch(spec_types=Tuple{Type{Base.Dict{K, V} where V where K}, Pair{Symbol, Nothing}, Pair{Symbol, Array{QuadraticModels.PresolveOperation{Float64, Array{Float64, 1}}, 1}}}, sparams=svec(), method=(::Type{Base.Dict{K, V} where V where K})((Pair{A, B} where B where A)...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000034b9, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(&)), Tuple{Base.BitArray{1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<=)), Tuple{Array{Float64, 1}, Array{Float64, 1}}}}}, Type{Bool}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a90192c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(&)), Tuple{Base.BitArray{1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<=)), Tuple{Array{Float64, 1}, Array{Float64, 1}}}}}, Type{Bool}, Tuple{Base.OneTo{Int64}}}, sparams=svec(1), method=similar(Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{N}, Axes, F, Args} where Args<:Tuple where F where Axes, Type{Bool}, Any) where {N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047d5, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), Any, AbstractArray{Float64, 1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, Nothing, typeof(Base.identity), Tuple{Float64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228cb926a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.Broadcast.BroadcastStyle, AbstractArray{Float64, 1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, Nothing, typeof(Base.identity), Tuple{Float64}}}, sparams=svec(), method=materialize!(Base.Broadcast.BroadcastStyle, Any, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048bf, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.BroadcastStyle}, Type{Base.SubArray{T, 1, P, I, L}} where L where I where P where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226f3dd7e0)[ Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.BroadcastStyle}, Type{Base.SubArray{T, 1, P, I, L}} where L where I where P where T}, sparams=svec(T, 1), method=(::Type{Base.Broadcast.BroadcastStyle})(Type{var"#s677"} where var"#s677"<:AbstractArray{T, N}) where {T, N}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000479b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R, Array{R, 1} where R}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226cb4be00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R, Array{R, 1} where R}, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unwrap_unionall), Type{var"#s179"} where var"#s179"<:Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Float64}, Pair{Symbol, _A} where _A}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228f53d660)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unwrap_unionall), Type{var"#s179"} where var"#s179"<:Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Float64}, Pair{Symbol, _A} where _A}}, sparams=svec(), method=unwrap_unionall(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000360, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.__safe_setindex!), Array{Any, 1}, Any, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422899dfc20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.__safe_setindex!), Array{Any, 1}, Any, Int64}, sparams=svec(), method=__safe_setindex!(Array{Any, 1}, Any, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000111c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Array{ADNLPModels.ADNLPModel{Float64, Array{Float64, 1}, Array{Int64, 1}}, 1}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742289728be0)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Array{ADNLPModels.ADNLPModel{Float64, Array{Float64, 1}, Array{Int64, 1}}, 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.unaliascopy), Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Type{Array{T, 1}} where T, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226ef570a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Type{Array{T, 1}} where T, Tuple{Base.OneTo{Int64}}}, sparams=svec(T<:(Array{T, 1} where T)), method=similar(Type{T}, Tuple{Union{Integer, Base.OneTo{T} where T<:Integer}, Vararg{Union{Integer, Base.OneTo{T} where T<:Integer}}}) where {T<:(AbstractArray{T, N} where N where T)}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000129c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.real), var"#s179"}} where var"#s179"<:Tuple{Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64}}, typeof(Base.real), Tuple{Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64}}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228c03ec20)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.real), var"#s179"}} where var"#s179"<:Tuple{Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64}}, typeof(Base.real), Tuple{Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64}}, Tuple{Base.OneTo{Int64}}}, sparams=svec(Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.real), var"#s179"<:Tuple{Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64}}), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args}})(Any, Any, Any) where {Style, Axes, F, Args}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_result), Type, Type{Tuple{String, typeof(JSOSolvers.R2)}}, Any, Type{Tuple{String, typeof(JSOSolvers.R2)}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228efe9140)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_result), Type, Type{Tuple{String, typeof(JSOSolvers.R2)}}, Type{T}, Type{Tuple{String, typeof(JSOSolvers.R2)}}} where T, sparams=svec(T, Tuple{String, typeof(JSOSolvers.R2)}), method=promote_result(Type, Type, Type{T}, Type{S}) where {T, S}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000602, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Type{QuadraticModels.QPData{T, S, M1, M2}} where M2<:(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv) where M1<:(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv) where S where T<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228f5f37e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Type{QuadraticModels.QPData{T, S, M1, M2}} where M2<:(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv) where M1<:(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv) where S where T<:Real, 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.setindex_widen_up_to), Array{QuadraticModels.Col{T}, 1} where T, QuadraticModels.Col{T} where T, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e970580)[Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex_widen_up_to), Array{QuadraticModels.Col{T}, 1} where T, QuadraticModels.Col{T} where T, Int64}, sparams=svec(T<:(QuadraticModels.Col{T} where T)), method=setindex_widen_up_to(AbstractArray{T, N} where N, Any, Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001108, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LinearAlgebra.mul!), Any, LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4711", 2} where var"#s4711"<:T) where T, AbstractArray{T, 1} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(6, 0x7422830a2320)[ Core.MethodMatch(spec_types=Tuple{typeof(LinearAlgebra.mul!), ReverseDiff.TrackedArray{V, D, N, VA, DA} where DA where VA where N where D where V, LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4711", 2} where var"#s4711"<:T) where T, ReverseDiff.TrackedArray{V, D, 1, VA, DA} where DA where VA where D where V}, sparams=svec(), method=mul!(ReverseDiff.TrackedArray{V, D, N, VA, DA} where DA where VA where N where D where V, AbstractArray{T, 2} where T, ReverseDiff.TrackedArray{V, D, 1, VA, DA} where DA where VA where D where V), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(LinearAlgebra.mul!), Union{LinearAlgebra.Adjoint{T, var"#s5"} where var"#s5"<:Union{StaticArraysCore.StaticArray{Tuple{var"#s2"}, T, 1} where var"#s2", StaticArraysCore.StaticArray{Tuple{var"#s3", var"#s4"}, T, 2} where var"#s4" where var"#s3"}, LinearAlgebra.Diagonal{T, var"#s12"} where var"#s12"<:(StaticArraysCore.StaticArray{Tuple{var"#s13"}, T, 1} where var"#s13"), LinearAlgebra.Hermitian{T, var"#s9"} where var"#s9"<:(StaticArraysCore.StaticArray{Tuple{var"#s10", var"#s11"}, T, 2} where var"#s11" where var"#s10"), LinearAlgebra.LowerTriangular{T, var"#s17"} where var"#s17"<:(StaticArraysCore.StaticArray{Tuple{var"#s18", var"#s19"}, T, 2} where var"#s19" where var"#s18"), LinearAlgebra.Symmetric{T, var"#s6"} where var"#s6"<:(StaticArraysCore.StaticArray{Tuple{var"#s7", var"#s8"}, T, 2} where var"#s8" where var"#s7"), LinearAlgebra.Transpose{T, var"#s1"} where var"#s1"<:Union{StaticArraysCore.StaticArray{Tuple{var"#s2"}, T, 1} where var"#s2", StaticArraysCore.StaticArray{Tuple{var"#s3", var"#s4"}, T, 2} where var"#s4" where var"#s3"}, LinearAlgebra.UnitLowerTriangular{T, var"#s23"} where var"#s23"<:(StaticArraysCore.StaticArray{Tuple{var"#s24", var"#s25"}, T, 2} where var"#s25" where var"#s24"), LinearAlgebra.UnitUpperTriangular{T, var"#s20"} where var"#s20"<:(StaticArraysCore.StaticArray{Tuple{var"#s21", var"#s22"}, T, 2} where var"#s22" where var"#s21"), LinearAlgebra.UpperTriangular{T, var"#s14"} where var"#s14"<:(StaticArraysCore.StaticArray{Tuple{var"#s15", var"#s16"}, T, 2} where var"#s16" where var"#s15"), StaticArraysCore.StaticArray{Tuple{var"#s25"}, T, 1} where var"#s25", StaticArraysCore.StaticArray{Tuple{var"#s4", var"#s3"}, T, 2} where var"#s3" where var"#s4"} where T, LinearAlgebra.Symmetric{T, S} where S<:(StaticArraysCore.StaticArray{Tuple{var"#s7", var"#s8"}, T, 2} where var"#s8" where var"#s7") where T, StaticArraysCore.StaticArray{Tuple{var"#s25"}, T, 1} where var"#s25" where T}, sparams=svec(), method=mul!(Union{LinearAlgebra.Adjoint{T, var"#s5"} where var"#s5"<:Union{StaticArraysCore.StaticArray{Tuple{var"#s2"}, T, 1} where var"#s2", StaticArraysCore.StaticArray{Tuple{var"#s3", var"#s4"}, T, 2} where var"#s4" where var"#s3"}, LinearAlgebra.Diagonal{T, var"#s12"} where var"#s12"<:(StaticArraysCore.StaticArray{Tuple{var"#s13"}, T, 1} where var"#s13"), LinearAlgebra.Hermitian{T, var"#s9"} where var"#s9"<:(StaticArraysCore.StaticArray{Tuple{var"#s10", var"#s11"}, T, 2} where var"#s11" where var"#s10"), LinearAlgebra.LowerTriangular{T, var"#s17"} where var"#s17"<:(StaticArraysCore.StaticArray{Tuple{var"#s18", var"#s19"}, T, 2} where var"#s19" where var"#s18"), LinearAlgebra.Symmetric{T, var"#s6"} where var"#s6"<:(StaticArraysCore.StaticArray{Tuple{var"#s7", var"#s8"}, T, 2} where var"#s8" where var"#s7"), LinearAlgebra.Transpose{T, var"#s1"} where var"#s1"<:Union{StaticArraysCore.StaticArray{Tuple{var"#s2"}, T, 1} where var"#s2", StaticArraysCore.StaticArray{Tuple{var"#s3", var"#s4"}, T, 2} where var"#s4" where var"#s3"}, LinearAlgebra.UnitLowerTriangular{T, var"#s23"} where var"#s23"<:(StaticArraysCore.StaticArray{Tuple{var"#s24", var"#s25"}, T, 2} where var"#s25" where var"#s24"), LinearAlgebra.UnitUpperTriangular{T, var"#s20"} where var"#s20"<:(StaticArraysCore.StaticArray{Tuple{var"#s21", var"#s22"}, T, 2} where var"#s22" where var"#s21"), LinearAlgebra.UpperTriangular{T, var"#s14"} where var"#s14"<:(StaticArraysCore.StaticArray{Tuple{var"#s15", var"#s16"}, T, 2} where var"#s16" where var"#s15"), StaticArraysCore.StaticArray{Tuple{var"#s25"}, T, 1} where var"#s25", StaticArraysCore.StaticArray{Tuple{var"#s4", var"#s3"}, T, 2} where var"#s3" where var"#s4"} where T, Union{LinearAlgebra.Adjoint{T, var"#s5"} where var"#s5"<:Union{StaticArraysCore.StaticArray{Tuple{var"#s2"}, T, 1} where var"#s2", StaticArraysCore.StaticArray{Tuple{var"#s3", var"#s4"}, T, 2} where var"#s4" where var"#s3"}, LinearAlgebra.Diagonal{T, var"#s12"} where var"#s12"<:(StaticArraysCore.StaticArray{Tuple{var"#s13"}, T, 1} where var"#s13"), LinearAlgebra.Hermitian{T, var"#s9"} where var"#s9"<:(StaticArraysCore.StaticArray{Tuple{var"#s10", var"#s11"}, T, 2} where var"#s11" where var"#s10"), LinearAlgebra.LowerTriangular{T, var"#s17"} where var"#s17"<:(StaticArraysCore.StaticArray{Tuple{var"#s18", var"#s19"}, T, 2} where var"#s19" where var"#s18"), LinearAlgebra.Symmetric{T, var"#s6"} where var"#s6"<:(StaticArraysCore.StaticArray{Tuple{var"#s7", var"#s8"}, T, 2} where var"#s8" where var"#s7"), LinearAlgebra.Transpose{T, var"#s1"} where var"#s1"<:Union{StaticArraysCore.StaticArray{Tuple{var"#s2"}, T, 1} where var"#s2", StaticArraysCore.StaticArray{Tuple{var"#s3", var"#s4"}, T, 2} where var"#s4" where var"#s3"}, LinearAlgebra.UnitLowerTriangular{T, var"#s23"} where var"#s23"<:(StaticArraysCore.StaticArray{Tuple{var"#s24", var"#s25"}, T, 2} where var"#s25" where var"#s24"), LinearAlgebra.UnitUpperTriangular{T, var"#s20"} where var"#s20"<:(StaticArraysCore.StaticArray{Tuple{var"#s21", var"#s22"}, T, 2} where var"#s22" where var"#s21"), LinearAlgebra.UpperTriangular{T, var"#s14"} where var"#s14"<:(StaticArraysCore.StaticArray{Tuple{var"#s15", var"#s16"}, T, 2} where var"#s16" where var"#s15"), StaticArraysCore.StaticArray{Tuple{var"#s25"}, T, 1} where var"#s25", StaticArraysCore.StaticArray{Tuple{var"#s4", var"#s3"}, T, 2} where var"#s3" where var"#s4"} where T, Union{LinearAlgebra.Adjoint{T, var"#s5"} where var"#s5"<:Union{StaticArraysCore.StaticArray{Tuple{var"#s2"}, T, 1} where var"#s2", StaticArraysCore.StaticArray{Tuple{var"#s3", var"#s4"}, T, 2} where var"#s4" where var"#s3"}, LinearAlgebra.Diagonal{T, var"#s12"} where var"#s12"<:(StaticArraysCore.StaticArray{Tuple{var"#s13"}, T, 1} where var"#s13"), LinearAlgebra.Hermitian{T, var"#s9"} where var"#s9"<:(StaticArraysCore.StaticArray{Tuple{var"#s10", var"#s11"}, T, 2} where var"#s11" where var"#s10"), LinearAlgebra.LowerTriangular{T, var"#s17"} where var"#s17"<:(StaticArraysCore.StaticArray{Tuple{var"#s18", var"#s19"}, T, 2} where var"#s19" where var"#s18"), LinearAlgebra.Symmetric{T, var"#s6"} where var"#s6"<:(StaticArraysCore.StaticArray{Tuple{var"#s7", var"#s8"}, T, 2} where var"#s8" where var"#s7"), LinearAlgebra.Transpose{T, var"#s1"} where var"#s1"<:Union{StaticArraysCore.StaticArray{Tuple{var"#s2"}, T, 1} where var"#s2", StaticArraysCore.StaticArray{Tuple{var"#s3", var"#s4"}, T, 2} where var"#s4" where var"#s3"}, LinearAlgebra.UnitLowerTriangular{T, var"#s23"} where var"#s23"<:(StaticArraysCore.StaticArray{Tuple{var"#s24", var"#s25"}, T, 2} where var"#s25" where var"#s24"), LinearAlgebra.UnitUpperTriangular{T, var"#s20"} where var"#s20"<:(StaticArraysCore.StaticArray{Tuple{var"#s21", var"#s22"}, T, 2} where var"#s22" where var"#s21"), LinearAlgebra.UpperTriangular{T, var"#s14"} where var"#s14"<:(StaticArraysCore.StaticArray{Tuple{var"#s15", var"#s16"}, T, 2} where var"#s16" where var"#s15"), StaticArraysCore.StaticArray{Tuple{var"#s25"}, T, 1} where var"#s25", StaticArraysCore.StaticArray{Tuple{var"#s4", var"#s3"}, T, 2} where var"#s3" where var"#s4"} where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(LinearAlgebra.mul!), Any, LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4711", 2} where var"#s4711"<:T) where T, AbstractArray{T, 1} where T}, sparams=svec(), method=mul!(Any, Any, Any), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(StaticArrays.has_ndims), Type{StaticArraysCore.SArray{Tuple{1}, _A, N, L} where L where N} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74228e43bae0)[ Core.MethodMatch(spec_types=Tuple{typeof(StaticArrays.has_ndims), Type{StaticArraysCore.SArray{Tuple{1}, _A, N, L} where L} where _A} where N, sparams=svec(N), method=has_ndims(Type{var"#s25"} where var"#s25"<:(StaticArraysCore.StaticArray{var"#s24", var"#s23", N} where var"#s23" where var"#s24"<:Tuple)) where {N}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(StaticArrays.has_ndims), Type{StaticArraysCore.SArray{Tuple{1}, _A, N, L} where L where N} where _A}, sparams=svec(), method=has_ndims(Type{var"#s25"} where var"#s25"<:(StaticArraysCore.StaticArray{S, T, N} where N where T where S<:Tuple)), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000969d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.preprocess), Array{T, 1} where T<:Real, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.sqrt), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R<:Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422859cdc00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.preprocess), Array{T, 1} where T<:Real, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.sqrt), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R<:Real}}, sparams=svec(), method=preprocess(Any, Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048ca, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.to_indices), Array{T, 1} where T<:Real, Tuple{}, Tuple{}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a97e4fa0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.to_indices), Array{T, 1} where T<:Real, Tuple{}, Tuple{}}, sparams=svec(), method=to_indices(Any, Any, Tuple{}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000fdb, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IndexStyle}, Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s179"}} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real)}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226ea170e0)[ Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s179"}} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real)}}, sparams=svec(), method=(::Type{Base.IndexStyle})(Type{var"#s677"} where var"#s677"<:(Base.Broadcast.Broadcasted{var"#s676", var"#s675", F, Args} where Args<:Tuple where F where var"#s675"<:Tuple{Any} where var"#s676")), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047ea, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{LinearAlgebra.Adjoint{T, var"#s179"}} where var"#s179"<:SparseArrays.AbstractCompressedVector{T, Ti} where Ti where T<:Real where T, SparseArrays.AbstractCompressedVector{T, Ti} where Ti where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226c564260)[Core.MethodMatch(spec_types=Tuple{Type{LinearAlgebra.Adjoint{T, var"#s179"}} where var"#s179"<:SparseArrays.AbstractCompressedVector{T, Ti} where Ti where T<:Real where T, SparseArrays.AbstractCompressedVector{T, Ti} where Ti where T<:Real}, sparams=svec(), method=(::Type{LinearAlgebra.Adjoint{T, S}})(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000007ac4, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.preprocess), Nothing, Array{_A, 1} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742272c43500)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.preprocess), Nothing, Array{_A, 1} where _A}, sparams=svec(), method=preprocess(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048cb, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.print), Base.GenericIOBuffer{Memory{UInt8}}, Type}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7422847b68a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.print), Base.GenericIOBuffer{Memory{UInt8}}, Type}, sparams=svec(), method=print(IO, Any), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003da3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.real), Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(var"==")), typeof(DataType), Type{RipQP.LLDLFact}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422731b5060)[Core.MethodMatch(spec_types=Tuple{typeof(Base.:(var"==")), typeof(DataType), Type{RipQP.LLDLFact}}, sparams=svec(), method=var"=="(Type, Type), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000bcd, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Krylov.CgWorkspace{T, T, S} where S<:AbstractArray{T, 1} where T<:AbstractFloat, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228f61e240)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Krylov.CgWorkspace{T, T, S} where S<:AbstractArray{T, 1} where T<:AbstractFloat, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{RipQP.K2LDLParams{Float64, Fact} where Fact}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273a4bcc0)[Core.MethodMatch(spec_types=Tuple{Type{RipQP.K2LDLParams{Float64, Fact} where Fact}}, sparams=svec(Float64), method=(::Type{RipQP.K2LDLParams{T, Fact} where Fact})() where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Base.Iterators.Rest{I, Int64} where I<:(Array{Tv, 2} where Tv<:Real)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742284a8e420)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Base.Iterators.Rest{I, Int64} where I<:(Array{Tv, 2} where Tv<:Real)}, sparams=svec(), method=iterate(Base.Iterators.Rest{I, S} where S where I), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000190c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Iterators._zip_iterate_all), Tuple{Array{Int64, 1}, Array{T, 1} where T<:Real}, Tuple{Tuple{}, Tuple{}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228db85c60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators._zip_iterate_all), Tuple{Array{Int64, 1}, Array{T, 1} where T<:Real}, Tuple{Tuple{}, Tuple{}}}, sparams=svec(), method=_zip_iterate_all(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000018c4, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._any), Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.isreal)}, Base.Generator{_A, F} where F<:(LinearAlgebra.var"#Symmetric##0#Symmetric##1"{LinearAlgebra.Hermitian{T, S}} where S<:(AbstractArray{var"#s4711", 2} where var"#s4711"<:T) where T) where _A, Base.Colon}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x742288747da0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base._any), Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.isreal)}, Base.Generator{_A, F} where F<:(LinearAlgebra.var"#Symmetric##0#Symmetric##1"{LinearAlgebra.Hermitian{T, S}} where S<:(AbstractArray{var"#s4711", 2} where var"#s4711"<:T) where T) where _A, Base.Colon}, sparams=svec(), method=_any(Any, Any, Base.Colon), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001ad3, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.structural_eachindex), Array{ForwardDiff.Dual{Nothing, Float64, N}, 1} where N, Array{Float64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422749f7ce0)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.structural_eachindex), Array{ForwardDiff.Dual{Nothing, Float64, N}, 1} where N, Array{Float64, 1}}, sparams=svec(), method=structural_eachindex(AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009697, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), Any, AbstractArray{Float64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742287b413a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), Any, AbstractArray{Float64, 1}}, sparams=svec(), method=combine_styles(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004832, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.LinearIndices{N, R} where R<:Tuple{Vararg{Base.AbstractUnitRange{Int64}, N}} where N}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74228a22ab60)[ Core.MethodMatch(spec_types=Tuple{Type{Base.LinearIndices{N, R} where R<:Tuple{Vararg{Base.AbstractUnitRange{Int64}, N}} where N}, Tuple{Base.OneTo{Int64}}}, sparams=svec(1, Tuple{Base.OneTo{Int64}}), method=(::Type{Base.LinearIndices{N, R} where R where N})(R) where {N, R<:Tuple{Vararg{Base.AbstractUnitRange{Int64}, N}}}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000100e, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), RipQP.ResidualsHistory{T, S} where S where T<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d7cccc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), RipQP.ResidualsHistory{T, S} where S where T<:Real, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.preprocess_args), Nothing, Tuple{Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228cf6de00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.preprocess_args), Nothing, Tuple{Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64}}}, sparams=svec(), method=preprocess_args(Any, Tuple{Any}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048ce, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Base.RefValue{typeof(Base.:(<))}, Any, Float64} where var"#s175"<:Tuple{Base.RefValue{typeof(Base.:(<))}, Any, Float64}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273ab0860)[Core.MethodMatch(spec_types=Tuple{Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Base.RefValue{typeof(Base.:(<))}, Any, Float64} where var"#s175"<:Tuple{Base.RefValue{typeof(Base.:(<))}, Any, Float64}, Int64}, sparams=svec(var"#s175"<:Tuple{Base.RefValue{typeof(Base.:(<))}, Any, Float64}), method=(::Base.var"#cvt1#convert##0"{T, x})(Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000376, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Array{Tv, 1} where Tv<:Real, Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x742284f58da0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Array{Tv, 1} where Tv<:Real, Int64}, sparams=svec(), method=getindex(Array{T, N} where N where T, Int64), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Array{Tv, 1} where Tv<:Real, Integer}, sparams=svec(), method=getindex(Array{T, N} where N where T, Integer, Integer...), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012d2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Fix{1, F, T} where T where F}, Type{Base.MappingRF{F, T} where T where F}, Base.var"#_bool##0#_bool##1"{Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.iszero)}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d6c0180)[Core.MethodMatch(spec_types=Tuple{Type{Base.Fix{1, F, T} where T where F}, Type{Base.MappingRF{F, T} where T where F}, Base.var"#_bool##0#_bool##1"{Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.iszero)}}}, sparams=svec(1, UnionAll), method=(::Type{Base.Fix{N, F, T} where T where F})(F, Any) where {N, F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c46, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Type{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a8375a60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Type{Int64}}, sparams=svec(Int64), 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(Base.checkbounds), Type{Bool}, Array{Int64, 1}, Vararg{Any}}, limit=3), nothing, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.canonicalize2), Float32, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742287a08be0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.canonicalize2), Float32, Any}, sparams=svec(), method=canonicalize2(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002eb6, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.jac_coord!), Any, ADNLPModels.ADNLPModel{Float64, Array{Float64, 1}, Array{Int64, 1}}, Array{Float64, 1}, Array{Float64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x74226e8a5de0)[ Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_coord!), ADNLPModels.SparseADJacobian{Tag, R, T, C, S} where S where C where T where R where Tag, ADNLPModels.ADNLPModel{Float64, Array{Float64, 1}, Array{Int64, 1}}, Array{Float64, 1}, Array{Float64, 1}}, sparams=svec(), method=jac_coord!(ADNLPModels.SparseADJacobian{Tag, R, T, C, S} where S where C where T where R where Tag, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_coord!), ADNLPModels.ADBackend, ADNLPModels.ADNLPModel{Float64, Array{Float64, 1}, Array{Int64, 1}}, Array{Float64, 1}, Array{Float64, 1}}, sparams=svec(), method=jac_coord!(ADNLPModels.ADBackend, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_coord!), NLPModels.AbstractNLPModel{T, S} where S where T, ADNLPModels.ADNLPModel{Float64, Array{Float64, 1}, Array{Int64, 1}}, Array{Float64, 1}, Array{Float64, 1}}, sparams=svec(), method=jac_coord!(NLPModels.AbstractNLPModel{T, S} where S where T, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T), fully_covers=false), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096b3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isbits), Array{Tlow, 1} where Tlow<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422aa36c620)[Core.MethodMatch(spec_types=Tuple{typeof(Base.isbits), Array{Tlow, 1} where Tlow<:Real}, sparams=svec(), method=isbits(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000505, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.memoryref), Memory{T} where T<:(QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2} where T where S where M1 where M2), Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226e30eca0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.memoryref), Memory{T} where T<:(QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2} where T where S where M1 where M2), Int64}, sparams=svec(), method=memoryref(GenericMemory{isatomic, T, addrspace} where addrspace where T where isatomic, Integer), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000105, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.argtail), Tuple{Int64, Int64}, Tuple{Real, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228cb7dee0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.argtail), Tuple{Int64, Int64}, Tuple{Real, Int64}}, sparams=svec(), method=argtail(Any, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000035b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(QuadraticModels.slackdata), Any, Any, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74228e898ce0)[ Core.MethodMatch(spec_types=Tuple{typeof(QuadraticModels.slackdata), QuadraticModels.QPData{T, S, M1, M2}, NLPModels.NLPModelMeta{T, S} where S, Int64} where M2<:(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv) where M1<:(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv) where S where T, sparams=svec(T, S, M1<:(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv), M2<:(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv)), method=slackdata(QuadraticModels.QPData{T, S, M1, M2}, NLPModels.NLPModelMeta{T, S} where S, Int64) where {T, S, M1<:(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv), M2<:(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv)}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(QuadraticModels.slackdata), QuadraticModels.QPData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S, NLPModels.NLPModelMeta{T, S} where S, Int64} where T, sparams=svec(T), method=slackdata(QuadraticModels.QPData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S, NLPModels.NLPModelMeta{T, S} where S, Int64) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009745, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.haslength), Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Float64}, Pair{Symbol, _A} where _A}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228ec50020)[Core.MethodMatch(spec_types=Tuple{typeof(Base.haslength), Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Float64}, Pair{Symbol, _A} where _A}}, sparams=svec(), method=haslength(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000044d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.solver_type), RipQP.K2LDLParams{_A, RipQP.LDLFact} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228ebc4120)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.solver_type), RipQP.K2LDLParams{_A, RipQP.LDLFact} where _A}, sparams=svec(_A), method=solver_type(RipQP.SolverParams{T}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{ForwardDiff.Partials{1, Float64}}, Tuple{Bool}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422742f8b40)[Core.MethodMatch(spec_types=Tuple{Type{ForwardDiff.Partials{1, Float64}}, Tuple{Bool}}, sparams=svec(), method=(::Type{ForwardDiff.Partials{N, V}})(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009697, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:(RipQP.var"#PreconditionerData##2#PreconditionerData##3"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real), RipQP.var"#PreconditionerData##2#PreconditionerData##3"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226eefaee0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, RipQP.var"#PreconditionerData##2#PreconditionerData##3"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, RipQP.var"#PreconditionerData##2#PreconditionerData##3"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real} where T<:(RipQP.var"#PreconditionerData##2#PreconditionerData##3"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real), sparams=svec(T), method=convert(Type{T}, T) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000034c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), Tuple{typeof(DataType)}}, Type{LinearOperators.LinearOperator{Float64, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##10#PreconditionerData##11"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Nothing, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228a7578c0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), Tuple{typeof(DataType)}}, Type{LinearOperators.LinearOperator{Float64, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##10#PreconditionerData##11"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Nothing, Nothing}, sparams=svec(Float64, Int64), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, I, I, Bool, Bool, Any, Any, Any) where {T, I<:Integer}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{RipQP.var"##ripqp#131", Symbol, RipQP.K2LDLParams{_A, RipQP.LDLFact} where _A, Nothing, Nothing, RipQP.PC, Nothing, Nothing, Base.Pairs{Symbol, _A, I, A} where A<:(NamedTuple{names, T} where T<:Tuple where names) where I<:Tuple{Vararg{Symbol}} where _A, typeof(RipQP.ripqp), QuadraticModels.QuadraticModel{T, S, M1, M2} where M2 where M1 where S<:AbstractArray{T, 1} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228ec468c0)[Core.MethodMatch(spec_types=Tuple{RipQP.var"##ripqp#131", Symbol, RipQP.K2LDLParams{_A, RipQP.LDLFact} where _A, Nothing, Nothing, RipQP.PC, Nothing, Nothing, Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where T<:Tuple{Vararg{Any, N}} where names where N where V, typeof(RipQP.ripqp), QuadraticModels.QuadraticModel{T, S, M1, M2} where M2 where M1} where S<:AbstractArray{T, 1} where T, sparams=svec(T, S<:AbstractArray{T, 1}), method=var"#ripqp#131"(Symbol, RipQP.SolverParams{T} where T, Union{Nothing, RipQP.SolverParams{T} where T}, Union{Nothing, RipQP.SolverParams{T} where T}, RipQP.SolveMethod, Union{Nothing, RipQP.SolveMethod}, Union{Nothing, RipQP.SolveMethod}, Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where T<:Tuple{Vararg{Any, N}} where names where N where V, typeof(RipQP.ripqp), QuadraticModels.QuadraticModel{T, S, M1, M2} where M2 where M1) where {T, S<:AbstractArray{T, 1}}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.dict_with_eltype), Base.var"#Dict##0#Dict##1", Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A, Pair{Symbol, Array{T, 1}} where T<:Real, Pair{Symbol, Array{T, 1}} where T<:Real, Pair{Symbol, Array{T, 1}} where T<:Real, Pair{Symbol, Array{Int64, 1}}, Vararg{Pair{Symbol, Array{T, 1}} where T<:Real, 4}}, Type}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226eba6ee0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.dict_with_eltype), Base.var"#Dict##0#Dict##1", Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A, Pair{Symbol, Array{T, 1}} where T<:Real, Pair{Symbol, Array{T, 1}} where T<:Real, Pair{Symbol, Array{T, 1}} where T<:Real, Pair{Symbol, Array{Int64, 1}}, Vararg{Pair{Symbol, Array{T, 1}} where T<:Real, 4}}, Union{Type{Pair{K, V}}, Type{Tuple{K, V}}}} where V where K, sparams=svec(K, V), method=dict_with_eltype(Any, Any, Union{Type{Pair{K, V}}, Type{Tuple{K, V}}}) where {K, V}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.dict_with_eltype), Base.var"#Dict##0#Dict##1", Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A, Pair{Symbol, Array{T, 1}} where T<:Real, Pair{Symbol, Array{T, 1}} where T<:Real, Pair{Symbol, Array{T, 1}} where T<:Real, Pair{Symbol, Array{Int64, 1}}, Vararg{Pair{Symbol, Array{T, 1}} where T<:Real, 4}}, Type}, sparams=svec(Base.var"#Dict##0#Dict##1"), method=dict_with_eltype(F, Any, Any) where {F}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000178a, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.sort!), Array{Int64, 1}, Integer, Integer, Base.Sort.MergeSortAlg, Base.Order.ForwardOrdering, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x742274539a60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.sort!), Array{Int64, 1}, Integer, Integer, Base.Sort.MergeSortAlg, Base.Order.ForwardOrdering, Nothing}, sparams=svec(Int64), method=sort!(AbstractArray{T, 1}, Integer, Integer, Base.Sort.MergeSortAlg, Base.Order.Ordering, Union{Nothing, AbstractArray{T, 1}}) where {T}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000005d46, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{names, T} where T<:Tuple where names, Type{Krylov.GmresWorkspace{T, FC, S} where S where FC where T}, Any, Any, Any, Vararg{Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226e453820)[ Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{names, T} where T<:Tuple where names, Type{Krylov.GmresWorkspace{T, FC, S} where S where FC where T}, LLSModels.LLSModel{T, S, M1, M2} where M2 where M1 where S where T, Any, Any, Vararg{Any}}, sparams=svec(), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, Type{Krylov.GmresWorkspace{T, FC, S} where S where FC where T}, LLSModels.LLSModel{T, S, M1, M2} where M2 where M1 where S where T, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{names, T} where T<:Tuple where names, Type{Krylov.GmresWorkspace{T, FC, S} where S where FC where T}, Integer, Integer, Type}, sparams=svec(), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, Type{Krylov.GmresWorkspace{T, FC, S} where S where FC where T}, Integer, Integer, Type), fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isassigned), Memory{T} where T<:(QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2} where T where S where M1 where M2), Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226e8aa840)[Core.MethodMatch(spec_types=Tuple{typeof(Base.isassigned), Memory{T} where T<:(QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2} where T where S where M1 where M2), Int64}, sparams=svec(), method=isassigned(GenericMemory{isatomic, T, addrspace} where addrspace where T where isatomic, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000103f, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.identity), Tuple{Array{R, 1} where R}, Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742283174640)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.identity), Tuple{Array{R, 1} where R}, Tuple}, sparams=svec(typeof(Base.identity)), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ReverseDiff.tape), ReverseDiff.TrackedReal{V, D, O} where O where D<:Real where V<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74228e6765a0)[ Core.MethodMatch(spec_types=Tuple{typeof(ReverseDiff.tape), ReverseDiff.TrackedReal{V, D, O} where O where D<:Real where V<:Real}, sparams=svec(), method=tape(ReverseDiff.TrackedReal{V, D, O} where O where D<:Real where V<:Real), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, Type{T} where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##14#PreconditionerData##15"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Int64, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Tf<:Real) where Tlow<:Real, Nothing, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a7b66940)[Core.MethodMatch(spec_types=Tuple{Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, Type{T} where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##14#PreconditionerData##15"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Int64, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Tf<:Real) where Tlow<:Real, Nothing, Nothing}, sparams=svec(T<:Real, Int64), method=(::Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T})(Type{T}, I, I, Bool, Bool, Any, Any, Any) where {T, I<:Integer}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, typeof(RipQP.safe_boundary), Tuple{AbstractArray{Float64, 1}}, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422841c97a0)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, typeof(RipQP.safe_boundary), Tuple{AbstractArray{Float64, 1}}, Any}, sparams=svec(typeof(RipQP.safe_boundary)), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(LinearOperators.storage_type), var"#s179"} where var"#s179"<:Tuple{Tuple{Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T, LinearOperators.LinearOperator{_A, Int64, LinearOperators.var"#119#120", LinearOperators.var"#119#120", LinearOperators.var"#119#120", T} where T where _A}}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228bb7aba0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(LinearOperators.storage_type), var"#s179"} where var"#s179"<:Tuple{Tuple{Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T, LinearOperators.LinearOperator{_A, Int64, LinearOperators.var"#119#120", LinearOperators.var"#119#120", LinearOperators.var"#119#120", T} where T where _A}}, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.MappingRF{F, Base.MappingRF{Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}, Base.BottomRF{typeof(Base.add_sum)}}} where F<:(NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLPModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T), Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228881da80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.MappingRF{F, Base.MappingRF{Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}, Base.BottomRF{typeof(Base.add_sum)}}} where F<:(NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLPModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T), Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex_widen_up_to), Array{_A, 1} where _A, QuadraticModels.Col{T} where T, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d97bec0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex_widen_up_to), Array{_A, 1} where _A, QuadraticModels.Col{T} where T, Int64}, sparams=svec(_A), method=setindex_widen_up_to(AbstractArray{T, N} where N, Any, Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001108, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Ti, 1} where Ti<:Integer), Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422732ae9a0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Ti, 1} where Ti<:Integer), Int64}}, sparams=svec(), method=Typeof(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000028, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto_axcheck!), Array{T, 1} where T<:Number, Array{_A, 1} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d7f9980)[Core.MethodMatch(spec_types=Tuple{typeof(Base.copyto_axcheck!), Array{T, 1} where T<:Number, Array{_A, 1} where _A}, sparams=svec(), method=copyto_axcheck!(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012b7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.OrdinalRange{Int64, Int64}}, Base.StepRange{var"#s179", Int64} where var"#s179"<:Signed}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228807d160)[Core.MethodMatch(spec_types=Tuple{Type{Base.OrdinalRange{Int64, Int64}}, Base.StepRange{var"#s179", Int64} where var"#s179"<:Signed}, sparams=svec(Int64, Int64), method=(::Type{Base.OrdinalRange{T, S}})(Base.OrdinalRange{T, S} where S where T) where {T, S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000095d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), Any, AbstractArray{T, 1} where Float64<:T<:Real, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, Nothing, typeof(Base.identity), Tuple{Float64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422864eed20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.Broadcast.BroadcastStyle, AbstractArray{T, 1} where Float64<:T<:Real, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, Nothing, typeof(Base.identity), Tuple{Float64}}}, sparams=svec(), method=materialize!(Base.Broadcast.BroadcastStyle, Any, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048bf, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.in), UInt64, Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7422879f6560)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.in), UInt64, Tuple{Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Vararg{Any, N}} where N}, sparams=svec(), method=in(Any, Tuple{Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Vararg{Any, N}} where N), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.in), UInt64, Tuple}, sparams=svec(), method=in(Any, Tuple), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c68, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.result_style), Base.Broadcast.DefaultArrayStyle{0}, Base.Broadcast.BroadcastStyle}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74228ae11ba0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.result_style), Base.Broadcast.DefaultArrayStyle{0}, Base.Broadcast.DefaultArrayStyle{0}}, sparams=svec(Base.Broadcast.DefaultArrayStyle{0}), method=result_style(S, S) where {S<:Base.Broadcast.BroadcastStyle}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.result_style), Base.Broadcast.DefaultArrayStyle{0}, Base.Broadcast.BroadcastStyle}, sparams=svec(), method=result_style(Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004838, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, Type{Float64}, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##14#PreconditionerData##15"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real, Nothing, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422877fca20)[Core.MethodMatch(spec_types=Tuple{Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, Type{Float64}, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##14#PreconditionerData##15"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real, Nothing, Nothing}, sparams=svec(Float64, Int64), method=(::Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T})(Type{T}, I, I, Bool, Bool, Any, Any, Any) where {T, I<:Integer}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.length), LinearAlgebra.Symmetric{Float64, S} where S<:(AbstractArray{var"#s4711", 2} where var"#s4711"<:Float64)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x742288b06520)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.length), LinearAlgebra.Symmetric{Float64, S} where S<:(StaticArraysCore.StaticArray{Tuple{var"#s7", var"#s8"}, Float64, 2} where var"#s8" where var"#s7")}, sparams=svec(), method=length(Union{LinearAlgebra.Adjoint{T, var"#s5"} where var"#s5"<:Union{StaticArraysCore.StaticArray{Tuple{var"#s2"}, T, 1} where var"#s2", StaticArraysCore.StaticArray{Tuple{var"#s3", var"#s4"}, T, 2} where var"#s4" where var"#s3"}, LinearAlgebra.Diagonal{T, var"#s12"} where var"#s12"<:(StaticArraysCore.StaticArray{Tuple{var"#s13"}, T, 1} where var"#s13"), LinearAlgebra.Hermitian{T, var"#s9"} where var"#s9"<:(StaticArraysCore.StaticArray{Tuple{var"#s10", var"#s11"}, T, 2} where var"#s11" where var"#s10"), LinearAlgebra.LowerTriangular{T, var"#s17"} where var"#s17"<:(StaticArraysCore.StaticArray{Tuple{var"#s18", var"#s19"}, T, 2} where var"#s19" where var"#s18"), LinearAlgebra.Symmetric{T, var"#s6"} where var"#s6"<:(StaticArraysCore.StaticArray{Tuple{var"#s7", var"#s8"}, T, 2} where var"#s8" where var"#s7"), LinearAlgebra.Transpose{T, var"#s1"} where var"#s1"<:Union{StaticArraysCore.StaticArray{Tuple{var"#s2"}, T, 1} where var"#s2", StaticArraysCore.StaticArray{Tuple{var"#s3", var"#s4"}, T, 2} where var"#s4" where var"#s3"}, LinearAlgebra.UnitLowerTriangular{T, var"#s23"} where var"#s23"<:(StaticArraysCore.StaticArray{Tuple{var"#s24", var"#s25"}, T, 2} where var"#s25" where var"#s24"), LinearAlgebra.UnitUpperTriangular{T, var"#s20"} where var"#s20"<:(StaticArraysCore.StaticArray{Tuple{var"#s21", var"#s22"}, T, 2} where var"#s22" where var"#s21"), LinearAlgebra.UpperTriangular{T, var"#s14"} where var"#s14"<:(StaticArraysCore.StaticArray{Tuple{var"#s15", var"#s16"}, T, 2} where var"#s16" where var"#s15"), StaticArraysCore.StaticArray{Tuple{var"#s25"}, T, 1} where var"#s25", StaticArraysCore.StaticArray{Tuple{var"#s4", var"#s3"}, T, 2} where var"#s3" where var"#s4", StaticArraysCore.StaticArray{var"#s25", T, N} where N where var"#s25"<:Tuple} where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.length), LinearAlgebra.Symmetric{Float64, S} where S<:(AbstractArray{var"#s4711", 2} where var"#s4711"<:Float64)}, sparams=svec(), method=length(AbstractArray{T, N} where N where T), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000969d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, Type{T} where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{T, Ti, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Ti<:Integer where T<:Real) where Tlow<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422733e3340)[Core.MethodMatch(spec_types=Tuple{Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, Type{T} where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{T, Ti, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Ti<:Integer where T<:Real) where Tlow<:Real}, sparams=svec(T<:Real, Int64), method=(::Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T})(Type{T}, I, I, Bool, Bool, Any) where {T, I<:Integer}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.check_broadcast_axes), Tuple, Base.SubArray{T, 1, P, I, L} where L where I where P where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742271072880)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.check_broadcast_axes), Tuple, Base.SubArray{T, 1, P, I, L} where L where I where P where T}, sparams=svec(), method=check_broadcast_axes(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004864, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Type{Base.RefValue{SparseArrays.LibSuiteSparse.cholmod_common_struct}}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273aede60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Type{Base.RefValue{SparseArrays.LibSuiteSparse.cholmod_common_struct}}, 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.typeintersect), Type{Tuple{Any, Any}}, Type{var"#s175"} where var"#s175"<:Tuple{AbstractArray{T, 1} where T, Array{T, 1} where T<:Number}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742271a4df00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.typeintersect), Type{Tuple{Any, Any}}, Type{var"#s175"} where var"#s175"<:Tuple{AbstractArray{T, 1} where T, Array{T, 1} where T<:Number}}, sparams=svec(), method=typeintersect(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000527, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Iterators._zip_iterate_some), Tuple{AbstractArray{typeof(DataType), 1}}, Tuple{Tuple{}}, Tuple{Base.Missing}, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228ce2a000)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators._zip_iterate_some), Tuple{AbstractArray{typeof(DataType), 1}}, Tuple{Tuple{}}, Tuple{Base.Missing}, Bool}, sparams=svec(), method=_zip_iterate_some(Any, Any, Tuple{Any, Vararg{Any}}, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000018c7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{SolverTools.var"##TRONTrustRegion#13", Base.Pairs{Symbol, _A, I, A} where A<:(NamedTuple{names, T} where T<:Tuple where names) where I<:Tuple{Vararg{Symbol}} where _A, Type{SolverTools.TRONTrustRegion{T, V} where V where T}, Int64, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d6b86c0)[Core.MethodMatch(spec_types=Tuple{SolverTools.var"##TRONTrustRegion#13", Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where T<:Tuple{Vararg{Any, N}} where names where N where V, Type{SolverTools.TRONTrustRegion{T, V} where V where T}, Int64, T} where T, sparams=svec(T), method=var"#TRONTrustRegion#13"(Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where T<:Tuple{Vararg{Any, N}} where names where N where V, Type{SolverTools.TRONTrustRegion{T, V} where V where T}, Int64, T) where {T}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096c0, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{ADNLPModels.var"##ADModelBackend#1", Symbol, Bool, Bool, Any, Any, Any, Base.Pairs{Symbol, Array{Float64, 1}, Tuple{Symbol}, NamedTuple{(:x0,), Tuple{Array{Float64, 1}}}}, Type{ADNLPModels.ADModelBackend{GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS} where HBLS where JBLS where JtvBLS where JvBLS where HvBLS where GHJ where HB where JB where JtvB where JvB where HvB where GB}, Int64, SolverTest.var"#16#17"}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228cbb7440)[Core.MethodMatch(spec_types=Tuple{ADNLPModels.var"##ADModelBackend#1", Symbol, Bool, Bool, Any, Any, Any, Base.Pairs{Symbol, Array{Float64, 1}, Tuple{Symbol}, NamedTuple{(:x0,), Tuple{Array{Float64, 1}}}}, Type{ADNLPModels.ADModelBackend{GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS} where HBLS where JBLS where JtvBLS where JvBLS where HvBLS where GHJ where HB where JB where JtvB where JvB where HvB where GB}, Int64, SolverTest.var"#16#17"}, sparams=svec(), method=var"#ADModelBackend#1"(Symbol, Bool, Bool, Any, Any, Any, Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where T<:Tuple{Vararg{Any, N}} where names where N where V, Type{ADNLPModels.ADModelBackend{GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS} where HBLS where JBLS where JtvBLS where JvBLS where HvBLS where GHJ where HB where JB where JtvB where JvB where HvB where GB}, Integer, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096b3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{NamedTuple{(:name,), T} where T<:Tuple}, Tuple{Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a77d4180)[Core.MethodMatch(spec_types=Tuple{Type{NamedTuple{(:name,), T} where T<:Tuple}, Tuple{Any}}, sparams=svec((:name,)), 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{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.abs), Tuple{Array{R, 1} where R}, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228f0cc6c0)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.abs), Tuple{Array{R, 1} where R}, Any}, sparams=svec(typeof(Base.abs)), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Dict{Symbol, QuadraticModels.PresolvedQuadraticModel{Float64, Array{Float64, 1}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742288b3b4c0)[Core.MethodMatch(spec_types=Tuple{Type{Base.Dict{Symbol, QuadraticModels.PresolvedQuadraticModel{Float64, Array{Float64, 1}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}}}}}, sparams=svec(Symbol, QuadraticModels.PresolvedQuadraticModel{Float64, Array{Float64, 1}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}}), method=(::Type{Base.Dict{K, V}})() where {K, V}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000034ae, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), RipQP.Point{Float64, S} where S<:AbstractArray{Float64, 1}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228926dce0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), RipQP.Point{Float64, S} where S<:AbstractArray{Float64, 1}, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, StaticArraysCore.StaticArrayStyle{2}, typeof(SparseMatricesCOO.replace_if_minusinf), Tuple{LinearAlgebra.Adjoint{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where Float64<:T<:Real, Float64}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742287746460)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, StaticArraysCore.StaticArrayStyle{2}, typeof(SparseMatricesCOO.replace_if_minusinf), Tuple{LinearAlgebra.Adjoint{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where Float64<:T<:Real, Float64}, Nothing}, sparams=svec(typeof(SparseMatricesCOO.replace_if_minusinf)), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.boundary_safety!), Any, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422839c8ac0)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.boundary_safety!), Any, Any}, sparams=svec(), method=boundary_safety!(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Iterators._zip_iterate_some), Tuple{Array{T, 1} where T<:Real}, Tuple{Tuple{Int64}}, Tuple{Base.Missing}, Base.Missing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228cf80520)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators._zip_iterate_some), Tuple{Array{T, 1} where T<:Real}, Tuple{Tuple{Int64}}, Tuple{Base.Missing}, Base.Missing}, sparams=svec(Base.Missing), method=_zip_iterate_some(Any, Any, Tuple{T, Vararg{Any}}, T) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000018c6, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Type{CodecZlib.ZStream}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d32d420)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Type{CodecZlib.ZStream}, 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(Core.kwcall), NamedTuple{(:droptol,), var"#s179"} where var"#s179"<:Tuple{Any}, typeof(LimitedLDLFactorizations.lldl_factorize!), LimitedLDLFactorizations.LimitedLDLFactorization{T, Ti, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Ti<:Integer where T<:Real, SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv<:Number}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742286098680)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:droptol,), var"#s179"} where var"#s179"<:Tuple{Any}, typeof(LimitedLDLFactorizations.lldl_factorize!), LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Int64, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T), SparseArrays.SparseMatrixCSC{Tv, Int64}} where Tv<:Number where Tf<:Real, sparams=svec(Tf<:Real, Tv<:Number, Int64), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(LimitedLDLFactorizations.lldl_factorize!), LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Ti, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T), SparseArrays.SparseMatrixCSC{Tv, Ti}) where {Tf<:Number, Tv<:Number, Ti<:Integer}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009769, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._tuple_error), Type{var"#s175"} where var"#s175"<:Tuple{Base.RefValue{typeof(Base.abs)}, Any}, Tuple{Base.RefValue{typeof(Base.abs)}, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422744c93c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._tuple_error), Type{var"#s175"} where var"#s175"<:Tuple{Base.RefValue{typeof(Base.abs)}, Any}, Tuple{Base.RefValue{typeof(Base.abs)}, Any}}, sparams=svec(), method=_tuple_error(Type, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000372, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{2}, typeof(SparseMatricesCOO.replace_if_minusinf), Tuple{LinearAlgebra.Adjoint{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where Float64<:T<:Real, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742282cb5820)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{2}, typeof(SparseMatricesCOO.replace_if_minusinf), Tuple{LinearAlgebra.Adjoint{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where Float64<:T<:Real, Float64}}, sparams=svec(typeof(SparseMatricesCOO.replace_if_minusinf)), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Ref{T} where T}, typeof(Base.max)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228a1091c0)[Core.MethodMatch(spec_types=Tuple{Type{Ref{T} where T}, typeof(Base.max)}, 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.promote_type), Type{Bool}, Type{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a92310e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_type), Type{Bool}, Type{Int64}}, sparams=svec(Bool, Int64), 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.getindex), Type{T} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742289eca200)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Type{T} where T<:Real}, sparams=svec(T<:Real), 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(Base.getproperty), GenericMemoryRef{:not_atomic, var"#s4711", Core.AddrSpace{Core}(0x00)} where var"#s4711"<:Float64, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742284e76ec0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), GenericMemoryRef{:not_atomic, var"#s4711", Core.AddrSpace{Core}(0x00)} where var"#s4711"<:Float64, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Type{RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LDLFactorizationData{Tlow}}} where Tlow<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422867c04e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Type{RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LDLFactorizationData{Tlow}}} where Tlow<:Real, 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(ReverseDiff._SpecialInstruction), typeof(Base.fill), Tuple{Real, Int64}, ReverseDiff.TrackedArray{V, _A, 1, VA, DA} where DA<:(Array{T, 1} where T) where VA<:(ReverseDiff.TrackedArray{V, D, N, VA, DA} where V where D where N where VA where DA) where _A where V<:(ReverseDiff.TrackedReal{V, D, ReverseDiff.TrackedArray{V, D, 1, VA, DA}} where V<:Real where D<:Real where VA<:(Array{T, 1} where T<:Real) where DA<:(Array{T, 1} where T<:Real)), Tuple{ReverseDiff.var"#24#25"{Tuple{Int64}}, ReverseDiff.var"##fill#277#23", NamedTuple{(), Tuple{}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a75032c0)[Core.MethodMatch(spec_types=Tuple{typeof(ReverseDiff._SpecialInstruction), typeof(Base.fill), Tuple{Real, Int64}, ReverseDiff.TrackedArray{V, _A, 1, VA, DA} where DA<:(Array{T, 1} where T) where VA<:(ReverseDiff.TrackedArray{V, D, N, VA, DA} where V where D where N where VA where DA) where _A where V<:(ReverseDiff.TrackedReal{V, D, ReverseDiff.TrackedArray{V, D, 1, VA, DA}} where V<:Real where D<:Real where VA<:(Array{T, 1} where T<:Real) where DA<:(Array{T, 1} where T<:Real)), Tuple{ReverseDiff.var"#24#25"{Tuple{Int64}}, ReverseDiff.var"##fill#277#23", NamedTuple{(), Tuple{}}}}, sparams=svec(typeof(Base.fill), I<:Tuple{Real, Int64}, O<:(ReverseDiff.TrackedArray{V, _A, 1, VA, DA} where DA<:(Array{T, 1} where T) where VA<:(ReverseDiff.TrackedArray{V, D, N, VA, DA} where V where D where N where VA where DA) where _A where V<:(ReverseDiff.TrackedReal{V, D, ReverseDiff.TrackedArray{V, D, 1, VA, DA}} where V<:Real where D<:Real where VA<:(Array{T, 1} where T<:Real) where DA<:(Array{T, 1} where T<:Real))), Tuple{ReverseDiff.var"#24#25"{Tuple{Int64}}, ReverseDiff.var"##fill#277#23", NamedTuple{(), Tuple{}}}), method=_SpecialInstruction(F, I, O, C) where {F, I, O, C}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{RipQP.var"##InputTol#8", Int64, Int64, Int64, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Float64, Type{RipQP.InputTol{T, I} where I<:Integer where T<:Real}, Type{T0} where T0<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422705eafc0)[Core.MethodMatch(spec_types=Tuple{RipQP.var"##InputTol#8", Int64, Int64, Int64, Real, Real, Real, Real, Real, Real, Real, Real, Real, Real, Real, Real, Float64, Type{RipQP.InputTol{T, I} where I<:Integer where T<:Real}, Type{T}} where T<:Real, sparams=svec(T<:Real, I<:Integer), method=var"#InputTol#8"(I, I, I, T, T, T, T, T, T, T, T, T, T, T, T, Float64, Type{RipQP.InputTol{T, I} where I<:Integer where T<:Real}, Type{T}) where {T<:Real, I<:Integer}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.iter!), RipQP.Point{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T<:Real where T<:Real, RipQP.IterData{T, S} where S where T<:Real, RipQP.QM_FloatData_ref{T, _A, M1, M2} where M2<:(Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T<:Real) where M1<:(Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T<:Real) where _A where T<:Real, RipQP.QM_IntData, RipQP.AbstractResiduals{T, S} where S where T<:Real, RipQP.StopCrit{Float64}, RipQP.DescentDirectionAllocs{T, S} where S where T<:Real, RipQP.PreallocatedDataK2LDL{T, _A, F, _B} where _B<:AbstractArray{T, 2} where F<:(RipQP.LDLFactorizationData{T} where T) where _A where T<:Real, RipQP.Tolerances{T} where T<:Real, RipQP.Counters, RipQP.InputConfig{Int64}, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742274269f20)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.iter!), Union{RipQP.Point{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T<:Real, RipQP.Point{T, S} where S<:AbstractArray{T, 1} where T<:Real}, RipQP.IterData{T, S} where S, RipQP.QM_FloatData_ref{T, _A, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where _A, RipQP.QM_IntData, RipQP.AbstractResiduals{T, S} where S, RipQP.StopCrit{Float64}, RipQP.DescentDirectionAllocs{T, S} where S, RipQP.PreallocatedDataK2LDL{T, _A, F, _B} where _B<:AbstractArray{T, 2} where F<:(RipQP.LDLFactorizationData{T} where T) where _A, RipQP.Tolerances{T}, RipQP.Counters, RipQP.InputConfig{Int64}, Bool} where T<:Real, sparams=svec(T<:Real, Float64), method=iter!(RipQP.Point{T, S} where S, RipQP.IterData{T, S} where S, RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S, RipQP.QM_IntData, RipQP.AbstractResiduals{T, S} where S, RipQP.StopCrit{Tc}, RipQP.DescentDirectionAllocs{T, S} where S, RipQP.PreallocatedData{T, S} where S, RipQP.Tolerances{T}, RipQP.Counters, RipQP.InputConfig{I} where I<:Integer, Bool) where {T<:Real, Tc<:Real}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.get), Base.IdDict{Any, Any}, GenericMemoryRef{:not_atomic, T, Core.AddrSpace{Core}(0x00)} where T, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742285d9ae00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.get), Base.IdDict{Any, Any}, GenericMemoryRef{:not_atomic, T, Core.AddrSpace{Core}(0x00)} where T, Symbol}, sparams=svec(Any, Any), method=get(Base.IdDict{K, V}, Any, Any) where {K, V}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000017a3, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), Memory{K} where Symbol<:K<:Any, Symbol, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74228a4b3620)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Memory{Any}, Symbol, Int64}, sparams=svec(), method=setindex!(Memory{Any}, Any, Int64), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Memory{K} where Symbol<:K<:Any, Symbol, Int64}, sparams=svec(Symbol<:K<:Any), method=setindex!(Memory{T}, Any, Int64) where {T}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000105c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex_widen_up_to), Array{_A, 1} where _A, Any, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a83ad420)[Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex_widen_up_to), Array{_A, 1} where _A, Any, Int64}, sparams=svec(_A), method=setindex_widen_up_to(AbstractArray{T, N} where N, Any, Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001108, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Array{Tv, 2} where Tv<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742284986120)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Array{Tv, 2} where Tv<:Real}, sparams=svec(), method=iterate(Array{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001110, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isdone), Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.setup_log_header), RipQP.PreallocatedDataK2LDL{Float64, _A, F, M} where M<:AbstractArray{Float64, 2} where F<:(RipQP.LDLFactorizationData{T} where T) where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422733c14c0)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.setup_log_header), RipQP.PreallocatedDataK2LDL{Float64, _A, F, M} where M<:AbstractArray{Float64, 2} where F<:(RipQP.LDLFactorizationData{T} where T) where _A}, sparams=svec(Float64), method=setup_log_header(RipQP.PreallocatedData{T, S} where S) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.typeintersect), Type{Tuple{Any}}, Type{var"#s175"} where var"#s175"<:Tuple{FillArrays.Zeros{_A, 1, Tuple{Base.OneTo{Int64}}} where _A}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742272d5cc00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.typeintersect), Type{Tuple{Any}}, Type{var"#s175"} where var"#s175"<:Tuple{FillArrays.Zeros{_A, 1, Tuple{Base.OneTo{Int64}}} where _A}}, sparams=svec(), method=typeintersect(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000527, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._array_for), Type{QuadraticModels.Row{Float64}}, Base.HasShape{1}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742286a17d20)[Core.MethodMatch(spec_types=Tuple{typeof(Base._array_for), Type{QuadraticModels.Row{Float64}}, Base.HasShape{1}, Tuple{Base.OneTo{Int64}}}, sparams=svec(QuadraticModels.Row{Float64}, 1), method=_array_for(Type{T}, Base.HasShape{N}, Any) where {T, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010f1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{QuadraticModels.QPData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S where T}, Any, Any, SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv, SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228c988ca0)[Core.MethodMatch(spec_types=Tuple{Type{QuadraticModels.QPData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S where T}, Any, Any, SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv, SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv}, sparams=svec(), method=(::Type{QuadraticModels.QPData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S where T})(Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009745, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Any, 1}}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228de1e220)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Any, 1}}}, Int64}, sparams=svec(), method=getindex(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000669, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.BroadcastStyle}, Type{Base.RefValue{typeof(Base.identity)}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a9a3c900)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.BroadcastStyle}, Type{Base.RefValue{typeof(Base.identity)}}}, sparams=svec(Base.RefValue{typeof(Base.identity)}), method=(::Type{Base.Broadcast.BroadcastStyle})(Type{T}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000479c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Int64}, UInt64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422748b28c0)[Core.MethodMatch(spec_types=Tuple{Type{Int64}, UInt64}, 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.Broadcast.broadcasted), typeof(Base.:(+)), AbstractArray{T, 1} where T<:Real, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226e419ee0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(+)), AbstractArray{T, 1} where T<:Real, Any}, sparams=svec(typeof(Base.:(+))), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004959, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(*)), var"#s179"} where var"#s179"<:Tuple{Int64, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Int64, Base.IteratorsMD.CartesianIndex{0}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422738ab220)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(*)), var"#s179"} where var"#s179"<:Tuple{Int64, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Int64, Base.IteratorsMD.CartesianIndex{0}}, sparams=svec(2), method=getindex(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Vararg{Union{Integer, Base.IteratorsMD.CartesianIndex{N} where N}, N}) where {N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000487c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.tail), Tuple{AbstractArray{typeof(DataType), 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228cf8bc40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.tail), Tuple{AbstractArray{typeof(DataType), 1}}}, sparams=svec(), method=tail(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000035d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), Tuple{Base.RefValue{typeof(Base.:(-))}, Array{Float64, 1}, AbstractArray{T, N} where N where T}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a9d5e680)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), Tuple{Base.RefValue{typeof(Base.:(-))}, Array{Float64, 1}, AbstractArray{T, N} where N where T}}, sparams=svec(), method=Typeof(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000028, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), LinearAlgebra.Diagonal{T, V} where V<:Array{T, 1} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226ec705e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.size), LinearAlgebra.Diagonal{T, Union{}} where T<:Real}, sparams=svec(), method=size(Union{LinearAlgebra.Adjoint{T, var"#s5"} where var"#s5"<:Union{StaticArraysCore.StaticArray{Tuple{var"#s2"}, T, 1} where var"#s2", StaticArraysCore.StaticArray{Tuple{var"#s3", var"#s4"}, T, 2} where var"#s4" where var"#s3"}, LinearAlgebra.Diagonal{T, var"#s12"} where var"#s12"<:(StaticArraysCore.StaticArray{Tuple{var"#s13"}, T, 1} where var"#s13"), LinearAlgebra.Hermitian{T, var"#s9"} where var"#s9"<:(StaticArraysCore.StaticArray{Tuple{var"#s10", var"#s11"}, T, 2} where var"#s11" where var"#s10"), LinearAlgebra.LowerTriangular{T, var"#s17"} where var"#s17"<:(StaticArraysCore.StaticArray{Tuple{var"#s18", var"#s19"}, T, 2} where var"#s19" where var"#s18"), LinearAlgebra.Symmetric{T, var"#s6"} where var"#s6"<:(StaticArraysCore.StaticArray{Tuple{var"#s7", var"#s8"}, T, 2} where var"#s8" where var"#s7"), LinearAlgebra.Transpose{T, var"#s1"} where var"#s1"<:Union{StaticArraysCore.StaticArray{Tuple{var"#s2"}, T, 1} where var"#s2", StaticArraysCore.StaticArray{Tuple{var"#s3", var"#s4"}, T, 2} where var"#s4" where var"#s3"}, LinearAlgebra.UnitLowerTriangular{T, var"#s23"} where var"#s23"<:(StaticArraysCore.StaticArray{Tuple{var"#s24", var"#s25"}, T, 2} where var"#s25" where var"#s24"), LinearAlgebra.UnitUpperTriangular{T, var"#s20"} where var"#s20"<:(StaticArraysCore.StaticArray{Tuple{var"#s21", var"#s22"}, T, 2} where var"#s22" where var"#s21"), LinearAlgebra.UpperTriangular{T, var"#s14"} where var"#s14"<:(StaticArraysCore.StaticArray{Tuple{var"#s15", var"#s16"}, T, 2} where var"#s16" where var"#s15"), StaticArraysCore.StaticArray{Tuple{var"#s25"}, T, 1} where var"#s25", StaticArraysCore.StaticArray{Tuple{var"#s4", var"#s3"}, T, 2} where var"#s3" where var"#s4", StaticArraysCore.StaticArray{var"#s25", T, N} where N where var"#s25"<:Tuple} where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.size), LinearAlgebra.Diagonal{T, V} where V<:Array{T, 1} where T<:Real}, sparams=svec(), method=size(LinearAlgebra.Diagonal{T, V} where V<:AbstractArray{T, 1} 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.isbitstype), Type{Base.SubArray{T, 1, P, I, L}} where L where I where P where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d533360)[Core.MethodMatch(spec_types=Tuple{typeof(Base.isbitstype), Type{Base.SubArray{T, 1, P, I, L}} where L where I where P where T}, sparams=svec(), method=isbitstype(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000503, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), Tuple{LinearAlgebra.Adjoint{Float64, var"#s179"} where var"#s179"<:AbstractArray{Float64, 1}, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d32d960)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), Tuple{LinearAlgebra.Adjoint{Float64, var"#s179"} where var"#s179"<:AbstractArray{Float64, 1}, Float64}}, sparams=svec(), method=Typeof(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000028, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.identity), Base.BottomRF{T} where T<:Function}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422aa976a80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.identity), Base.BottomRF{T} where T<:Function}, sparams=svec(), method=identity(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000be5, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.map), ForwardDiff.var"#extract_derivative!##2#extract_derivative!##3"{T} where T, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.to_index), Array{var"#s4711", 1} where var"#s4711"<:Float64, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742284ac4060)[Core.MethodMatch(spec_types=Tuple{typeof(Base.to_index), Array{var"#s4711", 1} where var"#s4711"<:Float64, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(), method=to_index(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000fcb, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Any, Base.RefValue{T} where T, Any, Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226e300740)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Any, Base.RefValue{T} where T, Any, Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}}}, sparams=svec(), method=(::Type{MethodError})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000009d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.diff_fallback), NamedTuple{(:x0,), var"#s179"} where var"#s179"<:Tuple{Array{_A, 1} where _A}, Tuple{Symbol}, NTuple{10, Symbol}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742272d51a60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.diff_fallback), NamedTuple{(:x0,), var"#s179"} where var"#s179"<:Tuple{Array{_A, 1} where _A}, Tuple{Symbol}, NTuple{10, Symbol}}, sparams=svec(), method=diff_fallback(NamedTuple{names, T} where T<:Tuple where names, Tuple{Vararg{Symbol}}, Tuple{Vararg{Symbol}}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001ab3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Dict{_A, _B}} where _B where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a9e37bc0)[Core.MethodMatch(spec_types=Tuple{Type{Base.Dict{_A, _B}} where _B where _A}, sparams=svec(_A, _B), method=(::Type{Base.Dict{K, V}})() where {K, V}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000034ae, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.ComposedFunction{O, I} where I where O}, Base.ComposedFunction{typeof(Base.identity), Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLPModel{T, S, Si}, Array{Int64, 1}, Int64}}} where Si where S where T, Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742285d5b2a0)[Core.MethodMatch(spec_types=Tuple{Type{Base.ComposedFunction{O, I} where I where O}, Base.ComposedFunction{typeof(Base.identity), Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLPModel{T, S, Si}, Array{Int64, 1}, Int64}}} where Si where S where T, Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}}}, sparams=svec(), method=(::Type{Base.ComposedFunction{O, I} where I where O})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c23, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unwrap_unionall), Type{var"#s179"} where var"#s179"<:Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Any, 1}}, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Int64, 1}}, Vararg{Pair{Symbol, _A} where _A, 4}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a6c6a3e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unwrap_unionall), Type{var"#s179"} where var"#s179"<:Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Any, 1}}, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Int64, 1}}, Vararg{Pair{Symbol, _A} where _A, 4}}}, sparams=svec(), method=unwrap_unionall(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000360, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), LinearAlgebra.Symmetric{T, M} where M<:AbstractArray{T, 2} where T<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742288876960)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), LinearAlgebra.Symmetric{T, M} where M<:AbstractArray{T, 2} where T<:Real, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{LinearAlgebra.Diagonal{Float64, Array{Float64, 1}}}, Array{Float64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422746e8ce0)[Core.MethodMatch(spec_types=Tuple{Type{LinearAlgebra.Diagonal{Float64, Array{Float64, 1}}}, Array{Float64, 1}}, sparams=svec(Float64, Array{Float64, 1}), method=(::Type{LinearAlgebra.Diagonal{T, V}})(Any) where {T, V<:AbstractArray{T, 1}}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000008b01, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Tuple{Pair{Int64, Array{Base.Rational{Int64}, 1}}, Vararg{Pair{Int64, Array{Base.Rational{Int64}, 1}}}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a712bd60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Tuple{Pair{Int64, Array{Base.Rational{Int64}, 1}}, Vararg{Pair{Int64, Array{Base.Rational{Int64}, 1}}}}, Int64}, sparams=svec(), method=iterate(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000067b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422712ffd00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Int64}, sparams=svec(), method=checkbounds(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Integer), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004886, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.haslength), Tuple{Pair{Symbol, Nothing}, Pair{Symbol, Array{QuadraticModels.PresolveOperation{T, _A}, 1}} where _A where T<:Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d654de0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.haslength), Tuple{Pair{Symbol, Nothing}, Pair{Symbol, Array{QuadraticModels.PresolveOperation{T, _A}, 1}} where _A where T<:Real}}, sparams=svec(), method=haslength(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000044d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{QuadraticModels.QPData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S where T}, Real, Any, Any, AbstractArray{T, 2} where T, AbstractArray{T, 2} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226fe7b380)[Core.MethodMatch(spec_types=Tuple{Type{QuadraticModels.QPData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S where T}, Real, S, S, M1, M2} where M2<:AbstractArray{T, 2} where M1<:AbstractArray{T, 2} where S where T, sparams=svec(T, S, M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}, M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}), method=(::Type{QuadraticModels.QPData{T, S, M1, M2} where M2 where M1 where S where T})(T, S, S, M1, M2) where {T, S, M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}, M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009745, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.show_log_row_krylov), RipQP.PreallocatedData{Float64, S} where S<:AbstractArray{Float64, 1}, RipQP.IterData{Float64, S} where S<:AbstractArray{Float64, 1}, RipQP.AbstractResiduals{Float64, S} where S<:AbstractArray{Float64, 1}, RipQP.Counters, Float64, Float64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422898e0f40)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.show_log_row_krylov), RipQP.PreallocatedData{Float64, S} where S<:AbstractArray{Float64, 1}, RipQP.IterData{Float64, S} where S<:AbstractArray{Float64, 1}, RipQP.AbstractResiduals{Float64, S} where S<:AbstractArray{Float64, 1}, RipQP.Counters, Float64, Float64}, sparams=svec(Float64), method=show_log_row_krylov(RipQP.PreallocatedData{T, S} where S, RipQP.IterData{T, S} where S, RipQP.AbstractResiduals{T, S} where S, RipQP.Counters, T, T) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.eltypes), Tuple{FillArrays.AbstractZeros{T, 1, Axes} where Axes where T<:Real, Array{R, 1} where R<:Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228b214600)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.eltypes), Tuple{FillArrays.AbstractZeros{T, 1, Axes} where Axes where T<:Real, Array{R, 1} where R<:Real}}, sparams=svec(), method=eltypes(Tuple{Any, Any}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048ab, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), var"#s179"} where var"#s179"<:Tuple{Type}, Type{LinearOperators.LinearOperator{_A, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where _A, Int64, Int64, Bool, Bool, LinearOperators.var"#119#120", LinearOperators.var"#119#120", LinearOperators.var"#119#120", Int64, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a753cf80)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), var"#s179"} where var"#s179"<:Tuple{Type}, Type{LinearOperators.LinearOperator{_A, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where _A, Int64, Int64, Bool, Bool, LinearOperators.var"#119#120", LinearOperators.var"#119#120", LinearOperators.var"#119#120", Int64, Int64, Int64}, sparams=svec(_A, Int64, LinearOperators.var"#119#120", LinearOperators.var"#119#120", LinearOperators.var"#119#120"), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, I, I, Bool, Bool, F, Ft, Fct, I, I, I) where {T, I<:Integer, F, Ft, Fct}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), Any, Any, Any, Base.RefValue{T} where T, AbstractArray{T, N} where N where T, Array{T, N} where N where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226e791b60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Base.Broadcast.BroadcastStyle, F, Any, Base.RefValue{T} where T, AbstractArray{T, N} where N where T, Array{T, N} where N where T} where F, sparams=svec(F<:F), method=broadcasted(Base.Broadcast.BroadcastStyle, F, Any...) where {F}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Any, Any, Any, Base.RefValue{T} where T, AbstractArray{T, N} where N where T, Array{T, N} where N where T}, sparams=svec(F), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000495a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Generator{I, F} where F where I}, QuadraticModels.var"#get_arows_acols##2#get_arows_acols##3"{Float64, Array{Int64, 1}}, Base.UnitRange{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228764bee0)[Core.MethodMatch(spec_types=Tuple{Type{Base.Generator{I, F} where F where I}, QuadraticModels.var"#get_arows_acols##2#get_arows_acols##3"{Float64, Array{Int64, 1}}, Base.UnitRange{Int64}}, sparams=svec(Base.UnitRange{Int64}, QuadraticModels.var"#get_arows_acols##2#get_arows_acols##3"{Float64, Array{Int64, 1}}), method=(::Type{Base.Generator{I, F} where F where I})(F, I) where {I, F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000420, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Type{Bool}, Array{var"#s4711", 1} where var"#s4711"<:Float64, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226eb3cca0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Type{Bool}, Array{var"#s4711", 1} where var"#s4711"<:Float64, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(), method=checkbounds(Type{Bool}, AbstractArray{T, N} where N where T, Any), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000127a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LinearAlgebra.ldiv!), RipQP.LDLFactorizationData{T} where T, AbstractArray{Float64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422724683c0)[Core.MethodMatch(spec_types=Tuple{typeof(LinearAlgebra.ldiv!), RipQP.LDLFactorizationData{T} where T, AbstractArray{Float64, 1}}, sparams=svec(), method=ldiv!(RipQP.LDLFactorizationData{T} where T, AbstractArray{T, 1} where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.map), Base.var"#view##0#view##1"{Array{T, 1}} where T<:Real, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a92b3960)[Core.MethodMatch(spec_types=Tuple{typeof(Base.map), Base.var"#view##0#view##1"{Array{T, 1}} where T<:Real, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}}, sparams=svec(), method=map(Any, Tuple{Any}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006bc, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), LDLFactorizations.LDLFactorization{Tf, Int64, Int64, Int64} where Tf<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226e116e80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), LDLFactorizations.LDLFactorization{Tf, Int64, Int64, Int64} where Tf<:Real, Symbol}, sparams=svec(), method=getproperty(LDLFactorizations.LDLFactorization{T, Ti, Tn, Tp} where Tp<:Integer where Tn<:Integer where Ti<:Integer where T<:Number, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009767, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), Tuple{Any, Any, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228a9242c0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), Tuple{Any, Any, Int64}}, sparams=svec(), method=Typeof(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000028, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.zeros), Any, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x742283638520)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.zeros), Type{T}, Int64} where T, sparams=svec(T), method=zeros(Type{T}, Union{Integer, Base.AbstractUnitRange{T} where T}...) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.zeros), Union{Integer, Base.AbstractUnitRange{T} where T}, Int64}, sparams=svec(), method=zeros(Union{Integer, Base.AbstractUnitRange{T} where T}...), fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010d0, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.length), Tuple{String, Type, String, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228da751a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.length), Tuple{String, Type, String, Any}}, sparams=svec(), method=length(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000664, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._similar_shape), Base.Generator{Base.UnitRange{Int64}, F} where F<:(Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##0#__cat_offset1!##1"{shape, catdims, offsets, x}} where x where offsets where catdims where shape), Base.HasShape{1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a88ec7a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._similar_shape), Base.Generator{Base.UnitRange{Int64}, F} where F<:(Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##0#__cat_offset1!##1"{shape, catdims, offsets, x}} where x where offsets where catdims where shape), Base.HasShape{1}}, sparams=svec(), method=_similar_shape(Any, Base.HasShape{N} where N), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010ea, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(-)), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a945f640)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(-)), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R}, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._broadcast_getindex_evalf), typeof(OperatorScaling.return_one_if_zero), Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742287c9b5c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._broadcast_getindex_evalf), typeof(OperatorScaling.return_one_if_zero), Any}, sparams=svec(typeof(OperatorScaling.return_one_if_zero), 1), method=_broadcast_getindex_evalf(Tf, Vararg{Any, N}) where {Tf, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000489e, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.axes1), FillArrays.AbstractFill{T, 1, Axes} where Axes where Float64<:T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226e790560)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.axes1), FillArrays.AbstractFill{T, 1, Axes} where Axes where Float64<:T<:Real}, sparams=svec(), method=axes1(AbstractArray{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001237, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{StaticArraysCore.Size{S} where S}, Type{StaticArraysCore.SArray{Tuple{1}, _A, N, L} where L where N} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74228dc03b60)[ Core.MethodMatch(spec_types=Tuple{Type{StaticArraysCore.Size{S} where S}, Type{StaticArraysCore.SArray{Tuple{1}, _A, N, L} where L where N} where _A}, sparams=svec(Tuple{1}, SA<:(StaticArraysCore.SArray{Tuple{1}, _A, N, L} where L where N where _A)), method=(::Type{StaticArraysCore.Size{S} where S})(Type{SA}) where {S<:Tuple, SA<:(StaticArraysCore.StaticArray{S, T, N} where N where T)}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000968c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Base.IdDict{Any, Any}, QuadraticModels.QPData{T, S, M1, M2} where M2<:(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv) where M1<:(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv) where S where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228f51f6a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Base.IdDict{Any, Any}, QuadraticModels.QPData{T, S, M1, M2} where M2<:(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv) where M1<:(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv) where S where T<:Real}, sparams=svec(Any, Any), method=getindex(Base.IdDict{K, V}, Any) where {K, V}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000017a4, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.methods), RipQP.var"#PreconditionerData##8#PreconditionerData##9"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{T, Ti, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Ti<:Integer where T<:Real) where Tlow<:Real, Type{Tuple}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228afaf120)[Core.MethodMatch(spec_types=Tuple{typeof(Base.methods), RipQP.var"#PreconditionerData##8#PreconditionerData##9"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{T, Ti, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Ti<:Integer where T<:Real) where Tlow<:Real, Type{Tuple}, Nothing}, sparams=svec(), method=methods(Any, Any, Union{Nothing, Base.AbstractSet{Module}, Tuple{Module}, AbstractArray{Module, N} where N}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000576, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.argtail), Array{R, 1} where R<:Real, Array{R, 1} where R<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228a763080)[Core.MethodMatch(spec_types=Tuple{typeof(Base.argtail), Array{R, 1} where R<:Real, Array{R, 1} where R<:Real}, sparams=svec(), method=argtail(Any, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000035b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._getindex), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Ti, 1} where Ti<:Integer), Int64}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742272c47c60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._getindex), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Ti, 1} where Ti<:Integer), Int64}, Int64}, sparams=svec(), method=_getindex(Tuple, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000489a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), Tuple{Base.RefValue{typeof(Base.:(<))}, Array{T, N} where N where T, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d9484a0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), Tuple{Base.RefValue{typeof(Base.:(<))}, Array{T, N} where N where T, Any}}, sparams=svec(), method=Typeof(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000028, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{var"#s175"} where var"#s175"<:(Array{ForwardDiff.Dual{Nothing, Float64, _A}, 1} where _A), Array{ForwardDiff.Dual{Nothing, Float64, _A}, 1} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226e977b20)[ Core.MethodMatch(spec_types=Tuple{Type{Union{}}, Array{ForwardDiff.Dual{Nothing, Float64, _A}, 1} where _A}, sparams=svec(), method=(::Type{Union{}})(Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{Array{ForwardDiff.Dual{Nothing, Float64, _A}, 1}}, Array{ForwardDiff.Dual{Nothing, Float64, _A}, 1}} where _A where _A, sparams=svec(T<:(ForwardDiff.Dual{Nothing, Float64, _A} where _A), 1, S<:(ForwardDiff.Dual{Nothing, Float64, _A} where _A)), method=(::Type{Array{T, N}})(AbstractArray{S, N}) where {T, N, S}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010df, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_eltype), Array{Ti, 1} where Ti<:Integer, Base.UnitRange{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74228a7ee1a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_eltype), Array{Int64, 1}, Base.UnitRange{Int64}}, sparams=svec(Int64), method=promote_eltype(AbstractArray{T, N} where N, (AbstractArray{T, N} where N)...) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_eltype), Array{Ti, 1} where Ti<:Integer, Base.UnitRange{Int64}}, sparams=svec(), method=promote_eltype(Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000134a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Tuple{String, Real, String}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228b81fd80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Tuple{String, Real, String}, Int64}, sparams=svec(), method=iterate(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000067b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Expr}, Symbol, Any, typeof(Base.:(var"==")), typeof(DataType)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742272f57fe0)[Core.MethodMatch(spec_types=Tuple{Type{Expr}, Symbol, Any, typeof(Base.:(var"==")), typeof(DataType)}, sparams=svec(), method=(::Type{Expr})(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000002d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.multi_centrality_corr!), RipQP.DescentDirectionAllocsPC{Float64, S} where S, RipQP.PreallocatedDataK2Krylov{Float64, S, M, MT, Pr, Ksol} where Ksol<:(Krylov.KrylovWorkspace{T, FC, S} where S where FC where T) where Pr<:(RipQP.PreconditionerData{T, S} where S where T<:Real) where MT<:Union{Int64, RipQP.MatrixTools{Float64}} where M<:Union{AbstractArray{Float64, 2}, LinearOperators.LinearOperator{Float64, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where S, RipQP.Point{Float64, S} where S<:AbstractArray{T, 1} where T<:Real, Any, Any, RipQP.IterData{Float64, S} where S, RipQP.QM_FloatData_ref{Float64, S, M1, M2} where M2<:Union{AbstractArray{Float64, 2}, LinearOperators.AbstractLinearOperator{Float64}} where M1<:Union{AbstractArray{Float64, 2}, LinearOperators.AbstractLinearOperator{Float64}} where S, RipQP.QM_IntData, RipQP.Counters, RipQP.AbstractResiduals{Float64, S} where S}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228c3bf140)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.multi_centrality_corr!), RipQP.DescentDirectionAllocsPC{Float64, S} where S, RipQP.PreallocatedDataK2Krylov{Float64, S, M, MT, Pr, Ksol} where Ksol<:(Krylov.KrylovWorkspace{T, FC, S} where S where FC where T) where Pr<:(RipQP.PreconditionerData{T, S} where S where T<:Real) where MT<:Union{Int64, RipQP.MatrixTools{Float64}} where M<:Union{AbstractArray{Float64, 2}, LinearOperators.LinearOperator{Float64, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where S, RipQP.Point{Float64, S} where S<:AbstractArray{T, 1} where T<:Real, Float64, Float64, RipQP.IterData{Float64, S} where S, RipQP.QM_FloatData_ref{Float64, S, M1, M2} where M2<:Union{AbstractArray{Float64, 2}, LinearOperators.AbstractLinearOperator{Float64}} where M1<:Union{AbstractArray{Float64, 2}, LinearOperators.AbstractLinearOperator{Float64}} where S, RipQP.QM_IntData, RipQP.Counters, RipQP.AbstractResiduals{Float64, S} where S}, sparams=svec(Float64), method=multi_centrality_corr!(RipQP.DescentDirectionAllocsPC{T, S} where S, RipQP.PreallocatedData{T, S} where S, RipQP.Point{T, S} where S, T, T, RipQP.IterData{T, S} where S, RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S, RipQP.QM_IntData, RipQP.Counters, RipQP.AbstractResiduals{T, S} where S) where {T<:Real}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:(RipQP.var"#PreconditionerData##14#PreconditionerData##15"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real), RipQP.var"#PreconditionerData##14#PreconditionerData##15"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226e8182a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, RipQP.var"#PreconditionerData##14#PreconditionerData##15"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, RipQP.var"#PreconditionerData##14#PreconditionerData##15"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real} where T<:(RipQP.var"#PreconditionerData##14#PreconditionerData##15"{var"#s179"} where var"#s179"<:RipQP.FactorizationData{Tlow} where Tlow<:Real), sparams=svec(T), method=convert(Type{T}, T) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000034c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), Base.SubArray{_A, _B, P, I, true} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.identity), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226f4050a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.SubArray{_A, _B, P, I, true} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.identity), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R}}, sparams=svec(), method=materialize!(Any, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048be, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{RipQP.StopCrit{Float64}, RipQP.QM_FloatData{T, S, M1, M2} where M2 where M1 where S where T<:Real, RipQP.QM_IntData, RipQP.Tolerances{T} where T<:Real, Union{RipQP.Residuals{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T<:Real where T<:Real, RipQP.ResidualsHistory{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T<:Real where T<:Real}, Union{RipQP.IterDataCPU{T, _A} where _A where T<:Real, RipQP.IterDataGPU{T, _A} where _A where T<:Real}, RipQP.Point{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T<:Real where T<:Real, Union{RipQP.ScaleDataLP{T, _A} where _A where T<:Real, RipQP.ScaleDataQP{T, _A} where _A where T<:Real}, RipQP.StartingPointData{T, S} where S where T<:Real, RipQP.Counters}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742270b72860)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{RipQP.StopCrit{Float64}, RipQP.QM_FloatData{T, S, M1, M2} where M2 where M1 where S where T<:Real, RipQP.QM_IntData, RipQP.Tolerances{T} where T<:Real, Union{RipQP.Residuals{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T<:Real where T<:Real, RipQP.ResidualsHistory{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T<:Real where T<:Real}, Union{RipQP.IterDataCPU{T, _A} where _A where T<:Real, RipQP.IterDataGPU{T, _A} where _A where T<:Real}, RipQP.Point{T, var"#s179"} where var"#s179"<:AbstractArray{T, 1} where T<:Real where T<:Real, Union{RipQP.ScaleDataLP{T, _A} where _A where T<:Real, RipQP.ScaleDataQP{T, _A} where _A where T<:Real}, RipQP.StartingPointData{T, S} where S where T<:Real, RipQP.Counters}, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000688, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), AbstractArray{T, N} where N where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a9c7d300)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), AbstractArray{T, N} where N where T}, sparams=svec(), method=combine_styles(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004830, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unaliascopy), Array{_A, 1} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a7f3bee0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unaliascopy), Array{_A, 1} where _A}, sparams=svec(), method=unaliascopy(Array{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000130b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.length), Array{T, 1} where Float64<:T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228676c480)[Core.MethodMatch(spec_types=Tuple{typeof(Base.length), Array{T, 1} where Float64<:T<:Real}, sparams=svec(Float64<:T<:Real), method=length(Array{T, 1}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000030c, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.check_broadcast_axes), Tuple{Base.OneTo{Int64}}, Array{R, 1} where R}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a7e190e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.check_broadcast_axes), Tuple{Base.OneTo{Int64}}, Array{R, 1} where R}, sparams=svec(), method=check_broadcast_axes(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004864, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.merge!), Base.Dict{K, V} where V where K, Base.Dict{K, V} where V where K}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422aa351500)[Core.MethodMatch(spec_types=Tuple{typeof(Base.merge!), Base.Dict{K, V} where V where K, Base.Dict{K, V} where V where K}, sparams=svec(), method=merge!(Base.AbstractDict{K, V} where V where K, (Base.AbstractDict{K, V} where V where K)...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000174b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_typejoin), Type{Int64}, typeof(DataType)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a9a89ac0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_typejoin), Type{Int64}, typeof(DataType)}, sparams=svec(), method=promote_typejoin(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000005e4, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Krylov.GmresWorkspace{T, FC, S} where S where FC where T}, Vararg{Any, 4}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742285c15440)[Core.MethodMatch(spec_types=Tuple{Type{Krylov.GmresWorkspace{T, FC, S} where S where FC where T}, LLSModels.LLSModel{T, S, M1, M2} where M2 where M1 where S where T, Any, Any, Any}, sparams=svec(), method=(::Type{Krylov.GmresWorkspace{T, FC, S} where S where FC where T})(LLSModels.LLSModel{T, S, M1, M2} where M2 where M1 where S where T, Any...), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), QuadraticModels.QuadraticModel{T, _A, M1, M2} where M2<:(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv) where M1<:(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv) where _A where T<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a94e7b00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), QuadraticModels.QuadraticModel{T, _A, M1, M2} where M2<:(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv) where M1<:(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv) where _A where T<:Real, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.result_join), Base.Broadcast.BroadcastStyle, Base.Broadcast.DefaultArrayStyle{N} where N, Any, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real)}}, UInt64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228b2adde0)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real)}}, UInt64}, sparams=svec(), method=(::Type{MethodError})(Any, Any, UInt64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000009c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Union{AbstractArray{T, 2}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where T<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226e66d720)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), SparseArrays.ReadOnly{T, 2, V} where V<:AbstractArray{T, 2} where T<:Real, Symbol}, sparams=svec(), method=getproperty(SparseArrays.ReadOnly{T, N, V} where V<:AbstractArray{T, N} where N where T, Symbol), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Union{AbstractArray{T, 2}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where T<:Real, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009675, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.throw_boundserror), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.abs), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real)}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a6f48640)[Core.MethodMatch(spec_types=Tuple{typeof(Base.throw_boundserror), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.abs), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real)}, Tuple{Int64}}, sparams=svec(), method=throw_boundserror(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000310, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.string), String, Number, String, Number, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d78d900)[Core.MethodMatch(spec_types=Tuple{typeof(Base.string), String, Number, String, Number, String}, sparams=svec(), method=string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003db1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, typeof(Base.:(<)), Tuple{Any, Float64}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273d2a600)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, typeof(Base.:(<)), Tuple{Any, Float64}, Nothing}, sparams=svec(typeof(Base.:(<))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, T}} where T where F<:(RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Int64, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Tf<:Real) where Tlow<:Real) where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Int64, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Tf<:Real) where Tlow<:Real, Nothing, Nothing, Int64, Int64, Int64, Bool, Bool, Any, Any, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a83223c0)[Core.MethodMatch(spec_types=Tuple{Type{LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, T}} where T where F<:(RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Int64, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Tf<:Real) where Tlow<:Real) where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{Tf, Int64, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Tf<:Real) where Tlow<:Real, Nothing, Nothing, Int64, Int64, Int64, Bool, Bool, Any, Any, Bool}, sparams=svec(), method=(::Type{LinearOperators.LinearOperator{T, I<:Integer, F, Ft, Fct, S}})(Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.tail), Tuple{Tuple{Int64, Int64}, Tuple{Real, Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228cb7d140)[Core.MethodMatch(spec_types=Tuple{typeof(Base.tail), Tuple{Tuple{Int64, Int64}, Tuple{Real, Int64}}}, sparams=svec(), method=tail(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000035d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), Base.Broadcast.DefaultArrayStyle{N} where N, Base.SubArray{_A, _B, P, I, true} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, Nothing, typeof(Base.identity), Tuple{Float64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228605a2c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.Broadcast.DefaultArrayStyle{N} where N, Base.SubArray{_A, _B, P, I, true} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, Nothing, typeof(Base.identity), Tuple{Float64}}}, sparams=svec(), method=materialize!(Base.Broadcast.BroadcastStyle, Any, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048bf, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{LinearOperators.LinearOperator{Float64, Int64, F, Nothing, Nothing, _A}} where _A where F<:(RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{T, Ti, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Ti<:Integer where T<:Real) where Tlow<:Real), Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{T, Ti, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Ti<:Integer where T<:Real) where Tlow<:Real, Nothing, Nothing, Int64, Int64, Int64, Bool, Bool, Any, Any, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742285d27900)[Core.MethodMatch(spec_types=Tuple{Type{LinearOperators.LinearOperator{Float64, Int64, F, Nothing, Nothing, _A}} where _A where F<:(RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{T, Ti, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Ti<:Integer where T<:Real) where Tlow<:Real), Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{T, Ti, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Ti<:Integer where T<:Real) where Tlow<:Real, Nothing, Nothing, Int64, Int64, Int64, Bool, Bool, Any, Any, Bool}, sparams=svec(), method=(::Type{LinearOperators.LinearOperator{T, I<:Integer, F, Ft, Fct, S}})(Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Array{QuadraticModels.Row{T}, 1} where T, Type}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e51d620)[Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Array{QuadraticModels.Row{T}, 1} where T, Type}, sparams=svec(T<:(QuadraticModels.Row{T} where T)), method=similar(Array{T, 1}, Type) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010b5, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._compute_eltype), Type{var"#s179"} where var"#s179"<:Tuple{Pair{Symbol, Nothing}, Vararg{Pair{A, B} where B where A}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742271d9b240)[Core.MethodMatch(spec_types=Tuple{typeof(Base._compute_eltype), Type{var"#s179"} where var"#s179"<:Tuple{Pair{Symbol, Nothing}, Vararg{Pair{A, B} where B where A}}}, sparams=svec(), method=_compute_eltype(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006ab, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.convert_types), Type{T} where T<:Real, RipQP.Point{T, S} where S where T<:Real, RipQP.IterData{T, S} where S where T<:Real, RipQP.AbstractResiduals{T, S} where S where T<:Real, RipQP.DescentDirectionAllocs{T, S} where S where T<:Real, RipQP.PreallocatedData{T, S} where S where T<:Real, RipQP.K2LDLParams{_A, RipQP.LDLFact} where _A, RipQP.SolverParams{T} where T<:Real, RipQP.QM_IntData, RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S where T<:Real, RipQP.PC, RipQP.PC}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226cc1b700)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.convert_types), Type{T}, RipQP.Point{T_old, S_old}, RipQP.IterData{T_old, S_old}, RipQP.AbstractResiduals{T_old, S_old}, RipQP.DescentDirectionAllocs{T_old, S_old}, RipQP.PreallocatedData{T_old, S} where S, RipQP.K2LDLParams{_A, RipQP.LDLFact} where _A, RipQP.SolverParams{T} where T<:Real, RipQP.QM_IntData, RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S where T<:Real, RipQP.PC, RipQP.PC} where S_old where T_old<:Real where T<:Real, sparams=svec(T<:Real, T_old<:Real, S_old), method=convert_types(Type{T}, RipQP.Point{T_old, S_old}, RipQP.IterData{T_old, S_old}, RipQP.AbstractResiduals{T_old, S_old}, RipQP.DescentDirectionAllocs{T_old, S_old}, RipQP.PreallocatedData{T_old, S} where S, Union{Nothing, RipQP.SolverParams{T} where T}, Union{Nothing, RipQP.SolverParams{T} where T}, RipQP.QM_IntData, RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where S where T<:Real, RipQP.SolveMethod, RipQP.SolveMethod) where {T<:Real, T_old<:Real, S_old}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SolverCore.solve!), Union{RipQP.RipQPTripleSolver{T, _A, Int64, _B, _C, Float64, T1, _D, _E, T2, _F, _G, _H} where _H<:(RipQP.PreallocatedFloatData{T1, _D, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T1, _D} where Dda<:RipQP.DescentDirectionAllocs{T1, _D} where Res<:RipQP.AbstractResiduals{T1, _D}) where _G<:(RipQP.Abstract_QM_FloatData{T, _A, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where _F<:(RipQP.Abstract_QM_FloatData{T2, S, M1, M2} where M2<:Union{AbstractArray{T2, 2}, LinearOperators.AbstractLinearOperator{T2}} where M1<:Union{AbstractArray{T2, 2}, LinearOperators.AbstractLinearOperator{T2}} where S) where T2<:Real where _E<:(RipQP.Abstract_QM_FloatData{T1, _D, M1, M2} where M2<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}} where M1<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}}) where _D where T1<:Real where _C<:RipQP.ScaleData{T, _A} where _B<:QuadraticModels.AbstractQuadraticModel{T, _A} where _A, RipQP.RipQPTripleSolver{T, _A, Int64, _B, _C, Float64, T1, S1, _E, T2, _F, _G, _H} where _H<:(RipQP.PreallocatedFloatData{T1, S1, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T1, S1} where Dda<:RipQP.DescentDirectionAllocs{T1, S1} where Res<:RipQP.AbstractResiduals{T1, S1}) where _G<:(RipQP.Abstract_QM_FloatData{T, _A, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where _F<:(RipQP.Abstract_QM_FloatData{T2, S, M1, M2} where M2<:Union{AbstractArray{T2, 2}, LinearOperators.AbstractLinearOperator{T2}} where M1<:Union{AbstractArray{T2, 2}, LinearOperators.AbstractLinearOperator{T2}} where S) where T2<:Real where _E<:(RipQP.Abstract_QM_FloatData{T1, S1, M1, M2} where M2<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}} where M1<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}}) where S1 where T1<:Real where _C<:RipQP.ScaleData{T, _A} where _B<:QuadraticModels.AbstractQuadraticModel{T, _A} where _A, RipQP.RipQPTripleSolver{T, S, Int64, _B, _C, Float64, T1, _D, _E, T2, _F, _G, _H} where _H<:(RipQP.PreallocatedFloatData{T1, _D, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T1, _D} where Dda<:RipQP.DescentDirectionAllocs{T1, _D} where Res<:RipQP.AbstractResiduals{T1, _D}) where _G<:(RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where _F<:(RipQP.Abstract_QM_FloatData{T2, S, M1, M2} where M2<:Union{AbstractArray{T2, 2}, LinearOperators.AbstractLinearOperator{T2}} where M1<:Union{AbstractArray{T2, 2}, LinearOperators.AbstractLinearOperator{T2}} where S) where T2<:Real where _E<:(RipQP.Abstract_QM_FloatData{T1, _D, M1, M2} where M2<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}} where M1<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}}) where _D where T1<:Real where _C<:RipQP.ScaleData{T, S} where _B<:QuadraticModels.AbstractQuadraticModel{T, S} where S, RipQP.RipQPTripleSolver{T, S, Int64, _B, _C, Float64, T1, S1, _E, T2, _F, _G, _H} where _H<:(RipQP.PreallocatedFloatData{T1, S1, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T1, S1} where Dda<:RipQP.DescentDirectionAllocs{T1, S1} where Res<:RipQP.AbstractResiduals{T1, S1}) where _G<:(RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where _F<:(RipQP.Abstract_QM_FloatData{T2, S, M1, M2} where M2<:Union{AbstractArray{T2, 2}, LinearOperators.AbstractLinearOperator{T2}} where M1<:Union{AbstractArray{T2, 2}, LinearOperators.AbstractLinearOperator{T2}} where S) where T2<:Real where _E<:(RipQP.Abstract_QM_FloatData{T1, S1, M1, M2} where M2<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}} where M1<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}}) where S1 where T1<:Real where _C<:RipQP.ScaleData{T, S} where _B<:QuadraticModels.AbstractQuadraticModel{T, S} where S} where T<:Real, QuadraticModels.AbstractQuadraticModel{T, S} where S where T<:Real, SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T, RipQP.RipQPTripleParameters{T, SP1, SP2, _A, RipQP.PC, RipQP.PC, RipQP.PC} where _A<:RipQP.SolverParams{T} where SP2<:(RipQP.SolverParams{T} where T) where SP1<:(RipQP.K2LDLParams{_A, RipQP.LDLFact} where _A) where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226dedc720)[Core.MethodMatch(spec_types=Tuple{typeof(SolverCore.solve!), RipQP.RipQPTripleSolver{T, S, Int64, _B, _C, Float64, T1, S1, _E, T2, _F, _G, _H} where _H<:(RipQP.PreallocatedFloatData{T1, S1, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T1, S1} where Dda<:RipQP.DescentDirectionAllocs{T1, S1} where Res<:RipQP.AbstractResiduals{T1, S1}) where _G<:(RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where _F<:(RipQP.Abstract_QM_FloatData{T2, S, M1, M2} where M2<:Union{AbstractArray{T2, 2}, LinearOperators.AbstractLinearOperator{T2}} where M1<:Union{AbstractArray{T2, 2}, LinearOperators.AbstractLinearOperator{T2}} where S) where T2<:Real where _E<:(RipQP.Abstract_QM_FloatData{T1, S1, M1, M2} where M2<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}} where M1<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}}) where S1 where T1<:Real where _C<:RipQP.ScaleData{T, S} where _B<:QuadraticModels.AbstractQuadraticModel{T, S}, QuadraticModels.AbstractQuadraticModel{T, S}, SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V, RipQP.RipQPTripleParameters{T, SP1, SP2, _A, RipQP.PC, RipQP.PC, RipQP.PC} where _A<:RipQP.SolverParams{T} where SP2<:(RipQP.SolverParams{T} where T) where SP1<:(RipQP.K2LDLParams{_A, RipQP.LDLFact} where _A) where T<:Real} where S where T<:Real, sparams=svec(T<:Real, S), method=solve!(RipQP.RipQPTripleSolver{T, S, I, QMType, Sd, Tsc, T1, S1, QMfd1, T2, QMfd2, QMfd3, Pfd} where Pfd<:(RipQP.PreallocatedFloatData{T1, S1, Res, Dda, Pad} where Pad<:RipQP.PreallocatedData{T1, S1} where Dda<:RipQP.DescentDirectionAllocs{T1, S1} where Res<:RipQP.AbstractResiduals{T1, S1}) where QMfd3<:(RipQP.Abstract_QM_FloatData{T, S, M1, M2} where M2<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where M1<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where QMfd2<:(RipQP.Abstract_QM_FloatData{T2, S, M1, M2} where M2<:Union{AbstractArray{T2, 2}, LinearOperators.AbstractLinearOperator{T2}} where M1<:Union{AbstractArray{T2, 2}, LinearOperators.AbstractLinearOperator{T2}} where S) where T2 where QMfd1<:(RipQP.Abstract_QM_FloatData{T1, S1, M1, M2} where M2<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}} where M1<:Union{AbstractArray{T1, 2}, LinearOperators.AbstractLinearOperator{T1}}) where S1 where T1 where Tsc<:Real where Sd<:RipQP.ScaleData{T, S} where QMType<:QuadraticModels.AbstractQuadraticModel{T, S} where I, QuadraticModels.AbstractQuadraticModel{T, S}, SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V, RipQP.RipQPTripleParameters{T, SP1, SP2, SP3, SM1, SM2, SM3} where SM3<:RipQP.SolveMethod where SM2<:RipQP.SolveMethod where SM1<:RipQP.SolveMethod where SP3<:RipQP.SolverParams{T} where SP2<:(RipQP.SolverParams{T} where T) where SP1<:(RipQP.SolverParams{T} where T) where T<:Real) where {T, S}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), AbstractArray{typeof(DataType), 1}}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.to_indices), Array{Tv, 1} where Tv<:Real, Tuple{Union{Integer, Base.IteratorsMD.CartesianIndex{N} where N}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(6, 0x742284645bf0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.to_indices), Array{Tv, 1} where Tv<:Real, Tuple{Int64}}, sparams=svec(), method=to_indices(Any, Tuple{Vararg{Int64}}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.to_indices), Array{Tv, 1} where Tv<:Real, Tuple{Integer}}, sparams=svec(), method=to_indices(Any, Tuple{Vararg{Integer}}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.to_indices), Array{Tv, 1} where Tv<:Real, Tuple{Union{Integer, Base.IteratorsMD.CartesianIndex{N} where N}}}, sparams=svec(), method=to_indices(Any, Tuple{Vararg{Union{Integer, Base.IteratorsMD.CartesianIndex{N} where N}}}), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000046ae, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isempty), AbstractArray{T, N} where N where T}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{LinearOperators.var"##LinearOperator#14", Type{Array{Tlow, 1}} where Tlow<:Real, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, Type{Tlow} where Tlow<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##8#PreconditionerData##9"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{T, Ti, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Ti<:Integer where T<:Real) where Tlow<:Real, Nothing, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228af43bc0)[Core.MethodMatch(spec_types=Tuple{LinearOperators.var"##LinearOperator#14", Type{Array{Tlow, 1}} where Tlow<:Real, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, Type{Tlow} where Tlow<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##8#PreconditionerData##9"{RipQP.LLDLFactorizationData{Tlow, F}} where F<:(LimitedLDLFactorizations.LimitedLDLFactorization{T, Ti, V1, V2} where V2<:(AbstractArray{T, 1} where T) where V1<:(AbstractArray{T, 1} where T) where Ti<:Integer where T<:Real) where Tlow<:Real, Nothing, Nothing}, sparams=svec(Tlow<:Real, Int64), method=var"#LinearOperator#14"(Any, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, Type{T}, I, I, Bool, Bool, Any, Any, Any) where {T, I<:Integer}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.copyto_nonleaf!), Base.BitArray{1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(*)), var"#s179"} where var"#s179"<:Tuple{Int64, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Base.OneTo{Int64}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422716cfce0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.copyto_nonleaf!), Base.BitArray{1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(*)), var"#s179"} where var"#s179"<:Tuple{Int64, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Base.OneTo{Int64}, Int64, Int64}, sparams=svec(), method=copyto_nonleaf!(Any, Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048f1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.axes), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(<=)), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R, Array{R, 1} where R}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228b2bbfc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.axes), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(<=)), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R, Array{R, 1} where R}}, sparams=svec(), method=axes(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047d8, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._setindex!), Array{ForwardDiff.Dual{Nothing, Float64, N}, 1} where N, ForwardDiff.Dual{Nothing, Float64, _A} where _A, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742287b8d2a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._setindex!), Array{ForwardDiff.Dual{Nothing, Float64, N}, 1}, ForwardDiff.Dual{Nothing, Float64, N}, Int64} where N, sparams=svec(T<:(ForwardDiff.Dual{Nothing, Float64, N} where N)), method=_setindex!(Array{T, N} where N, T, Int64) where {T}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001118, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:(Base.BitArray{_A} where _A), Base.BitArray{N} where N}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x742287fa9760)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Base.BitArray{N} where N}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:(Base.BitArray{_A} where _A), Base.BitArray{N} where N}, sparams=svec(var"#s175"<:(Base.BitArray{_A} where _A)), method=convert(Type{T}, AbstractArray{T, N} where N where T) where {T<:(Base.BitArray{N} where N)}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000015f2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.map), Type{Int64}, Tuple{Int64, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742285848740)[Core.MethodMatch(spec_types=Tuple{typeof(Base.map), Type{Int64}, Tuple{Int64, Int64}}, sparams=svec(), method=map(Any, Tuple{Any, Any}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006bd, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{RipQP.LRPrecond{Op1, Op2} where Op2 where Op1}, LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, T} where T where F<:(RipQP.var"#PreconditionerData##14#PreconditionerData##15"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}) where T<:Real, LinearAlgebra.UniformScaling{Bool}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228f70ee40)[Core.MethodMatch(spec_types=Tuple{Type{RipQP.LRPrecond{Op1, Op2} where Op2 where Op1}, LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, T} where T where F<:(RipQP.var"#PreconditionerData##14#PreconditionerData##15"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}) where T<:Real, LinearAlgebra.UniformScaling{Bool}}, sparams=svec(Op1<:(LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, T} where T where F<:(RipQP.var"#PreconditionerData##14#PreconditionerData##15"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}) where T<:Real), LinearAlgebra.UniformScaling{Bool}), method=(::Type{RipQP.LRPrecond{Op1, Op2} where Op2 where Op1})(Op1, Op2) where {Op1, Op2}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.UnitRange{T}} where T<:Signed, Signed, Signed}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74228ec4daa0)[ Core.MethodMatch(spec_types=Tuple{Type{Base.UnitRange{T}}, Signed, Signed} where T<:Signed, sparams=svec(T<:Real), method=(::Type{Base.UnitRange{T}})(T, T) where {T<:Real}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{Base.UnitRange{T}} where T<:Signed, Signed, Signed}, sparams=svec(T<:Signed), method=(::Type{Base.UnitRange{T}})(Any, Any) where {T<:Real}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000088b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.methods), RipQP.var"#PreconditionerData##16#PreconditionerData##17"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422aa9ab180)[Core.MethodMatch(spec_types=Tuple{typeof(Base.methods), RipQP.var"#PreconditionerData##16#PreconditionerData##17"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}}, sparams=svec(), method=methods(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000057a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.dict_with_eltype), Base.var"#Dict##0#Dict##1", Tuple{Pair{Symbol, QuadraticModels.PresolvedQuadraticModel{Float64, Array{Float64, 1}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}}}, Pair{Symbol, Array{QuadraticModels.PresolveOperation{Float64, Array{Float64, 1}}, 1}}}, Type{Pair{Symbol, B} where B}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422889553a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.dict_with_eltype), Base.var"#Dict##0#Dict##1", Tuple{Pair{Symbol, QuadraticModels.PresolvedQuadraticModel{Float64, Array{Float64, 1}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}}}, Pair{Symbol, Array{QuadraticModels.PresolveOperation{Float64, Array{Float64, 1}}, 1}}}, Type{Pair{Symbol, B} where B}}, sparams=svec(Base.var"#Dict##0#Dict##1"), method=dict_with_eltype(F, Any, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000178a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Iterators._zip_isdone), Tuple{Any, Base.OneTo{Int64}}, Tuple{Tuple{}, Tuple{}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a72795a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators._zip_isdone), Tuple{Any, Base.OneTo{Int64}}, Tuple{Tuple{}, Tuple{}}}, sparams=svec(), method=_zip_isdone(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000018ce, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.preprocess_args), FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}, Tuple{Array{T, 1} where T<:Number}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273cb11c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.preprocess_args), FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}, Tuple{Array{T, 1} where T<:Number}}, sparams=svec(), method=preprocess_args(Any, Tuple{Any}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048ce, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(>)), AbstractArray{T, 1} where T<:Real, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226e43b760)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(>)), AbstractArray{T, 1} where T<:Real, Any}, sparams=svec(typeof(Base.:(>))), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004959, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.has_bounds), NLPModels.NLPModelMeta{T, _A} where _A where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226f76d3c0)[Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.has_bounds), NLPModels.NLPModelMeta{T, _A} where _A where T<:Real}, sparams=svec(), method=has_bounds(NLPModels.AbstractNLPModelMeta{T, S} where S where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096b0, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, T}} where T where F<:(RipQP.var"#PreconditionerData##12#PreconditionerData##13"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real) where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##12#PreconditionerData##13"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Nothing, Nothing, Int64, Int64, Int64, Bool, Bool, Any, Any, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742271751240)[Core.MethodMatch(spec_types=Tuple{Type{LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, T}} where T where F<:(RipQP.var"#PreconditionerData##12#PreconditionerData##13"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real) where T<:Real, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##12#PreconditionerData##13"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Nothing, Nothing, Int64, Int64, Int64, Bool, Bool, Any, Any, Bool}, sparams=svec(), method=(::Type{LinearOperators.LinearOperator{T, I<:Integer, F, Ft, Fct, S}})(Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096af, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{TypeVar}, Any, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a9799fe0)[Core.MethodMatch(spec_types=Tuple{Type{TypeVar}, Any, Any}, sparams=svec(), method=(::Type{TypeVar})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000003d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{Union{Tuple{}, Tuple{Base.OneTo{Int64}}}, Union{Tuple{}, Tuple{Base.OneTo{Int64}}}}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228c435e60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{Union{Tuple{}, Tuple{Base.OneTo{Int64}}}, Union{Tuple{}, Tuple{Base.OneTo{Int64}}}}, Int64, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000689, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Array{Tv, 2} where Tv<:Real, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742284999ce0)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Array{Tv, 2} where Tv<:Real, 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.iterate), Tuple{Union{Char, Base.SubString{String}, String, Symbol}, String, String, String, Union{Char, Base.SubString{String}, String, Symbol}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273a1ad40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Tuple{Union{Char, Base.SubString{String}, String, Symbol}, String, String, String, Union{Char, Base.SubString{String}, String, Symbol}}}, sparams=svec(), method=iterate(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000067a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{RipQP.LDLFactorizationData{T} where T}, LDLFactorizations.LDLFactorization{T, Ti, Tn, Tp} where Tp<:Integer where Tn<:Integer where Ti<:Integer where T<:Number}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742270f13f40)[Core.MethodMatch(spec_types=Tuple{Type{RipQP.LDLFactorizationData{T} where T}, LDLFactorizations.LDLFactorization{T, Int64, Int64, Int64}} where T<:Number, sparams=svec(T<:Number), method=(::Type{RipQP.LDLFactorizationData{T} where T})(LDLFactorizations.LDLFactorization{T, Int64, Int64, Int64}) where {T}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Pair{Symbol, Array{T, 1}} where T<:Real, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422737705e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Pair{Symbol, Array{T, 1}} where T<:Real, Int64}, sparams=svec(), method=getindex(Pair{A, B} where B where A, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000007fa, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.sqrt), var"#s179"}} where var"#s179"<:Tuple{Array{R, 1} where R<:Real}, typeof(Base.sqrt), Tuple{Array{R, 1} where R<:Real}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742285a53e60)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.sqrt), var"#s179"}} where var"#s179"<:Tuple{Array{R, 1} where R<:Real}, typeof(Base.sqrt), Tuple{Array{R, 1} where R<:Real}, Tuple{Base.OneTo{Int64}}}, sparams=svec(Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.sqrt), var"#s179"<:Tuple{Array{R, 1} where R<:Real}), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args}})(Any, Any, Any) where {Style, Axes, F, Args}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LinearAlgebra.rdiv!), Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T<:Real, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._cshp), Int64, Tuple{Bool, Bool}, Tuple{Any, Any, Vararg{Any}}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228d961900)[Core.MethodMatch(spec_types=Tuple{typeof(Base._cshp), Int64, Tuple{Bool, Bool}, Tuple{Any, Any, Vararg{Any}}, Tuple{Int64}}, sparams=svec(), method=_cshp(Int64, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000139d, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Iterators._zip_iterate_interleave), Tuple{Any, Tuple{Int64, Int64}}, Tuple{}, Tuple{Any, Base.Missing}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74228992b7e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators._zip_iterate_interleave), Tuple{Any, Tuple{Int64, Int64}}, Tuple{}, Tuple{Bool, Base.Missing}}, sparams=svec(), method=_zip_iterate_interleave(Any, Any, Tuple{Bool, Vararg{Any}}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators._zip_iterate_interleave), Tuple{Any, Tuple{Int64, Int64}}, Tuple{}, Tuple{Any, Base.Missing}}, sparams=svec(), method=_zip_iterate_interleave(Any, Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000018cb, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unalias), Base.BitArray{N} where N, Base.LogicalIndex{Int64, Base.BitArray{N}} where N}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7422855d41a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.unalias), Base.BitArray{N} where N, Base.LogicalIndex{Int64, Base.BitArray{N}} where N}, sparams=svec(), method=unalias(Any, AbstractArray{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001307, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:display, :sp), var"#s179"} where var"#s179"<:Tuple{Bool, RipQP.K2LDLParams{_A, RipQP.LDLFact} where _A}, typeof(RipQP.ripqp), QuadraticModels.QuadraticModel{T, S, M1, M2} where M2 where M1 where S where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228efe89e0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:display, :sp), var"#s179"} where var"#s179"<:Tuple{Bool, RipQP.K2LDLParams{_A, RipQP.LDLFact} where _A}, typeof(RipQP.ripqp), QuadraticModels.QuadraticModel{T, S, M1, M2} where M2 where M1} where S<:AbstractArray{T, 1} where T, sparams=svec(T, S<:AbstractArray{T, 1}), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(RipQP.ripqp), QuadraticModels.QuadraticModel{T, S, M1, M2} where M2 where M1) where {T, S<:AbstractArray{T, 1}}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{RipQP.LDLData{T, Array{T, 1}, Tlow, RipQP.LRPrecond{Op1, Op2}, _A, RipQP.LDLFactorizationData{Tlow}}} where Tlow<:Real where _A where Op2 where Op1 where Tlow<:Real where T<:Real where T<:Real, Any, RipQP.Regularization{T} where T<:Real, RipQP.LDLFactorizationData{Tlow} where Tlow<:Real, Any, Any, Bool, Bool, LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, S} where S where F where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a9487560)[Core.MethodMatch(spec_types=Tuple{Type{RipQP.LDLData{T, Array{T, 1}, Tlow, RipQP.LRPrecond{Op1, Op2}, _A, RipQP.LDLFactorizationData{Tlow}}} where _A<:Union{AbstractArray{T, 2}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where Op2 where Op1 where Tlow<:Real where T<:Real where T<:Real, Any, RipQP.Regularization{T} where T<:Real, RipQP.LDLFactorizationData{Tlow} where Tlow<:Real, Any, Any, Bool, Bool, LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, S} where S where F where T}, sparams=svec(), method=(::Type{RipQP.LDLData{T<:Real, S, Tlow, Op<:Union{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T, RipQP.LRPrecond{Op1, Op2} where Op2 where Op1}, M<:Union{AbstractArray{T<:Real, 2}, LinearOperators.LinearOperator{T<:Real, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, F<:RipQP.FactorizationData{Tlow}}})(Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), SparseMatricesCOO.SparseMatrixCOO{T, Ti} where Ti<:Integer where Float64<:T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228381da40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), SparseMatricesCOO.SparseMatrixCOO{T, Ti} where Ti<:Integer where Float64<:T<:Real}, sparams=svec(), method=size(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009744, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), LinearAlgebra.Adjoint{Float64, var"#s179"} where var"#s179"<:AbstractArray{Float64, 1}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228e8dcb00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), LinearAlgebra.Adjoint{Float64, var"#s179"} where var"#s179"<:AbstractArray{Float64, 1}, Int64}, sparams=svec(Float64, 2), method=size(AbstractArray{T, N}, Any) where {T, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001228, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.has_offset_axes), Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unsafe_copyto!), Memory{T} where T, Int64, Memory{T} where T, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74228b54cfa0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_copyto!), Memory{T}, Int64, Memory{T}, Int64, Int64} where T, sparams=svec(T), method=unsafe_copyto!(Memory{T}, Any, Memory{T}, Any, Any) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_copyto!), Memory{T} where T, Int64, Memory{T} where T, Int64, Int64}, sparams=svec(), method=unsafe_copyto!(Memory{T} where T, Any, Memory{T} where T, Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001045, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(DiffResults.tuple_setindex), Tuple, Any, Type{Base.Val{1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a791dde0)[Core.MethodMatch(spec_types=Tuple{typeof(DiffResults.tuple_setindex), Tuple, Any, Type{Base.Val{1}}}, sparams=svec(Vararg, 1), method=tuple_setindex(Tuple{Vararg{Any, N}}, Any, Type{Base.Val{i}}) where {N, i}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000968d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IndexStyle}, Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(&)), Tuple{Base.Broadcast.Extruded{Base.BitArray{1}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<=)), Tuple{Base.Broadcast.Extruded{Array{Float64, 1}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{Array{Float64, 1}, Tuple{Bool}, Tuple{Int64}}}}}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x742288692620)[ Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(&)), Tuple{Base.Broadcast.Extruded{Base.BitArray{1}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<=)), Tuple{Base.Broadcast.Extruded{Array{Float64, 1}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{Array{Float64, 1}, Tuple{Bool}, Tuple{Int64}}}}}}}}, sparams=svec(), method=(::Type{Base.IndexStyle})(Type{var"#s677"} where var"#s677"<:(Base.Broadcast.Broadcasted{var"#s676", var"#s675", F, Args} where Args<:Tuple where F where var"#s675"<:Tuple{Any} where var"#s676")), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047ea, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IteratorSize}, Type{var"#s179"} where var"#s179"<:Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Any, 1}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(6, 0x74228ef763c0)[ Core.MethodMatch(spec_types=Tuple{Type{Base.IteratorSize}, Type{Union{}}}, sparams=svec(), method=(::Type{Base.IteratorSize})(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{Base.IteratorSize}, Type{var"#s179"} where var"#s179"<:Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, _A} where _A, Pair{Symbol, Array{Any, 1}}}}, sparams=svec(), method=(::Type{Base.IteratorSize})(Type{var"#s65"} where var"#s65"<:Tuple), fully_covers=true), #, #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000449, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), SparseArrays.SparseMatrixCSC{T, Int64} where T<:Real, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422aa9d15a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), SparseArrays.SparseMatrixCSC{T, Int64} where T<:Real, Int64}, sparams=svec(T<:Real, 2), method=size(AbstractArray{T, N}, Any) where {T, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001228, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.map), typeof(Base.first), Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(*)), Any, Base.SubArray{T, N, P, I, L} where L where I where P where N where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74228897cae0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(*)), Any, Base.SubArray{T, N, P, I, L} where L where I where P where N where T}, sparams=svec(typeof(Base.:(*))), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004959, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.abs), Tuple{Array{R, 1} where R}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a9d74920)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.abs), Tuple{Array{R, 1} where R}, Nothing}, sparams=svec(typeof(Base.abs)), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), Any, Integer, Int64}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Tuple{String, Nothing, String, Int64, String, Nothing, String, Nothing, String, String, Vararg{String}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422865ef580)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Tuple{String, Nothing, String, Int64, String, Nothing, String, Nothing, String, String, Vararg{String}}, Int64}, sparams=svec(), method=getindex(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000669, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Core.kwcall), Tuple{NamedTuple{names, T} where T<:Tuple where names, Type, Int64}, UInt64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228c9b4900)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Core.kwcall), Tuple{NamedTuple{names, T} where T<:Tuple where names, Type, Int64}, UInt64}, sparams=svec(), method=(::Type{MethodError})(Any, Any, UInt64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000009c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.sqrt), Array{T, 1} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74226ecfd8e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.sqrt), Array{T, 1} where T<:Real}, sparams=svec(typeof(Base.sqrt)), method=broadcasted(F, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004958, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unsafe_convert), Type{Base.Cstring}, Base.Cstring}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742271dc2600)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_convert), Type{Base.Cstring}, Base.Cstring}, sparams=svec(Base.Cstring), 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.unsafe_convert), Type{Ptr{Nothing}}, GenericMemoryRef{:not_atomic, T, Core.AddrSpace{Core}(0x00)} where T<:(QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2} where T where S where M1 where M2)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226e38de20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_convert), Type{Ptr{Nothing}}, GenericMemoryRef{:not_atomic, T, Core.AddrSpace{Core}(0x00)} where T<:(QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2} where T where S where M1 where M2)}, sparams=svec(T<:(QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2} where T where S where M1 where M2)), 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{typeof(Base.size), Array{T, 1} where T<:(ForwardDiff.Dual{Nothing, Float64, _A} where _A)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74227479cd60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), Array{T, 1} where T<:(ForwardDiff.Dual{Nothing, Float64, _A} where _A)}, sparams=svec(), method=size(Array{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001093, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.Iterators.Zip{Is} where Is<:Tuple{AbstractArray{T, 1} where T, AbstractArray{T, 1} where T}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a707cac0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.Iterators.Zip{Is} where Is<:Tuple{AbstractArray{T, 1} where T, AbstractArray{T, 1} where T}, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), AbstractArray{T, 1} where T<:Real, Array{Int64, 1}}, limit=3), nothing, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Type{Bool}, Array{Base.Rational{Int64}, 1}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7422894500a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Type{Bool}, Array{Base.Rational{Int64}, 1}, Int64}, sparams=svec(), method=checkbounds(Type{Bool}, AbstractArray{T, N} where N where T, Any), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000127a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{RipQP.ScaleData{T, S} where S where T<:Real}, RipQP.QM_FloatData{Float64, S, _A, _B} where _B where _A where S<:AbstractArray{Float64, 1}, RipQP.QM_IntData, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228ea6e400)[Core.MethodMatch(spec_types=Tuple{Type{RipQP.ScaleData{T, S} where S where T<:Real}, RipQP.QM_FloatData{Float64, S, _A, _B} where _B where _A where S<:AbstractArray{Float64, 1}, RipQP.QM_IntData, Bool}, sparams=svec(Float64, S<:AbstractArray{Float64, 1}), method=(::Type{RipQP.ScaleData{T, S} where S where T<:Real})(RipQP.QM_FloatData{T, S, M1, M2} where M2 where M1, RipQP.QM_IntData, Bool) where {T, S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{RipQP.IRWorkspace{T, S, Tr, Sr} where Sr<:AbstractArray{Tr, 1} where Tr where S<:AbstractArray{T, 1} where T}, Any, Any, Any, Any, Any, Bool, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742285d59460)[Core.MethodMatch(spec_types=Tuple{Type{RipQP.IRWorkspace{T, S, Tr, Sr} where Sr where Tr where S where T}, S, S, Sr, S, S, Bool, Int64} where Sr<:AbstractArray{Tr, 1} where Tr where S<:AbstractArray{T, 1} where T, sparams=svec(T, S<:AbstractArray{T, 1}, Tr, Sr<:AbstractArray{Tr, 1}), method=(::Type{RipQP.IRWorkspace{T, S, Tr, Sr} where Sr where Tr where S where T})(S, S, Sr, S, S, Bool, Int64) where {T, S<:AbstractArray{T, 1}, Tr, Sr<:AbstractArray{Tr, 1}}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000976d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a835a680)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Int64}, sparams=svec(1), method=getindex(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Vararg{Union{Integer, Base.IteratorsMD.CartesianIndex{N} where N}, N}) where {N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000487c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{SolverCore.GenericExecutionStats{Float64, Array{Float64, 1}, _A, _B}} where _B where _A, Bool, Symbol, Bool, Array{Float64, 1}, Bool, Float64, Bool, Float64, Bool, Float64, Bool, Array{Float64, 1}, Bool, Any, Any, Bool, Int64, Bool, Float64, Bool, Base.Dict{Symbol, Tsp} where Tsp}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742286b449c0)[Core.MethodMatch(spec_types=Tuple{Type{SolverCore.GenericExecutionStats{Float64, Array{Float64, 1}, _A, _B}} where _B where _A, Bool, Symbol, Bool, Array{Float64, 1}, Bool, Float64, Bool, Float64, Bool, Float64, Bool, Array{Float64, 1}, Bool, Any, Any, Bool, Int64, Bool, Float64, Bool, Base.Dict{Symbol, Tsp} where Tsp}, sparams=svec(), method=(::Type{SolverCore.GenericExecutionStats{T, S, V, Tsp}})(Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096bd, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.sqrt), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R<:Real}}, Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.sqrt), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R<:Real}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x74226ebd75a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.sqrt), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R<:Real}}}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.sqrt), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R<:Real}}} where T<:Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.sqrt), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R<:Real}}, sparams=svec(T<:Tuple), method=convert(Type{T}, T) where {T<:Tuple}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.sqrt), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R<:Real}}, Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.sqrt), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R<:Real}}}, sparams=svec(1, var"#s175"<:Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.sqrt), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R<:Real}}), 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{typeof(Base.dotgetproperty), RipQP.DescentDirectionAllocsPC{T, S} where S where T<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a86818e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.dotgetproperty), RipQP.DescentDirectionAllocsPC{T, S} where S where T<:Real, Symbol}, sparams=svec(), method=dotgetproperty(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000286, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._setindex!), Base.Dict{K, Any} where Symbol<:K<:Any, Nothing, Symbol, Int64, UInt8}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226d5fe3a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._setindex!), Base.Dict{K, Any} where Symbol<:K<:Any, Nothing, Symbol, Int64, UInt8}, sparams=svec(), method=_setindex!(Base.Dict{K, V} where V where K, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000034d7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), SparseArrays.SparseMatrixCSC{T, Int64} where T<:Number}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x742273796740)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), SparseArrays.SparseMatrixCSC{T, Int64} where T<:Number}, sparams=svec(), method=size(Union{SparseArrays.FixedSparseCSC{Tv, Ti} where Ti<:Integer where Tv, SparseArrays.SparseMatrixCSC{Tv, Ti} where Ti<:Integer where Tv}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009675, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcast), typeof(Base.:(>)), Any, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.collect_to!), Array{_A, 1} where _A, Base.Generator{I, typeof(Base.identity)} where I<:(Base.LogicalIndex{T, A} where A<:(AbstractArray{Bool, N} where N) where T), Int64, Tuple{Any, Any, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228622bd20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.collect_to!), Array{_A, 1} where _A, Base.Generator{I, typeof(Base.identity)} where I<:(Base.LogicalIndex{T, A} where A<:(AbstractArray{Bool, N} where N) where T), Int64, Tuple{Any, Any, Any}}, sparams=svec(_A), method=collect_to!(AbstractArray{T, N} where N, Any, Any, Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000110a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eps), Type{T} where T<:Real}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.dotgetproperty), RipQP.DescentDirectionAllocsIPF{Float64, S} where S, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226db10d00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.dotgetproperty), RipQP.DescentDirectionAllocsIPF{Float64, S} where S, Symbol}, sparams=svec(), method=dotgetproperty(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000286, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), Base.Broadcast.DefaultArrayStyle{2}, Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.iszero)}, Array{T, 2} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x74228afcc720)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Base.Broadcast.DefaultArrayStyle{2}, Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.iszero)}, Array{T, 2} where T}, sparams=svec(Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.iszero)}), method=broadcasted(Base.Broadcast.BroadcastStyle, F, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000495a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{Pair{A, B} where B where A, Int64}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422a6c2d920)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{Pair{A, B} where B where A, Int64}, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000688, 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, 0x74228e5c2200)[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{typeof(Core.Typeof), Tuple{Any, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R, Array{R, 1} where R}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226dcee3e0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), Tuple{Any, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R, Array{R, 1} where R}}}, sparams=svec(), method=Typeof(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000028, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Type{QuadraticModels.PresolveOperation{T, _A}} where _A where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74228cc736e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Type{QuadraticModels.PresolveOperation{T, _A}} where _A where T<:Real}, sparams=svec(T<:(QuadraticModels.PresolveOperation{T, _A} where T<:Real where _A)), 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(Base.Broadcast.restart_copyto_nonleaf!), Array{AbstractFloat, 1}, Array{Float32, 1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.imag), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64})}, Float64, Int64, Base.OneTo{Int64}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422aa0a5540)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.restart_copyto_nonleaf!), Array{AbstractFloat, 1}, Array{Float32, 1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.imag), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64})}, Float64, Int64, Base.OneTo{Int64}, Int64, Int64}, sparams=svec(), method=restart_copyto_nonleaf!(Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048ef, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.RefValue{typeof(Base.identity)}, Any}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7422aa4d4820)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.RefValue{typeof(Base.identity)}, Any}}}, sparams=svec(), method=(::Type{MethodError})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000009d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:(RipQP.var"#PreconditionerData##8#PreconditionerData##9"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real), RipQP.var"#PreconditionerData##8#PreconditionerData##9"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x74226e9e2260)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, RipQP.var"#PreconditionerData##8#PreconditionerData##9"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, RipQP.var"#PreconditionerData##8#PreconditionerData##9"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real} where T<:(RipQP.var"#PreconditionerData##8#PreconditionerData##9"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real), sparams=svec(T), method=convert(Type{T}, T) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000034c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R, Array{R, 1} where R}, typeof(DataType)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x74226e658d00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R, Array{R, 1} where R}, typeof(DataType)}, sparams=svec(T), method=similar(Base.Broadcast.Broadcasted{Style, Axes, F, Args} PkgEval terminated after 657.63s: test log exceeded the size limit