Package evaluation of JSOSolvers on Julia 1.13.0-DEV.853 (3e868b27cf*) started at 2025-07-16T23:32:08.696 ################################################################################ # Set-up # Installing PkgEval dependencies (TestEnv)... Set-up completed after 8.39s ################################################################################ # Installation # Installing JSOSolvers... Resolving package versions... Updating `~/.julia/environments/v1.13/Project.toml` [10dff2fc] + JSOSolvers v0.14.0 Updating `~/.julia/environments/v1.13/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.10.1+0 [8e850b90] + libblastrampoline_jll v5.13.1+0 Installation completed after 3.93s ################################################################################ # Precompilation # Precompiling PkgEval dependencies... Precompiling package dependencies... Precompilation completed after 520.25s ################################################################################ # Testing # Testing JSOSolvers Status `/tmp/jl_0JfubL/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_0JfubL/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.14 [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.10.1+0 [83775a58] Zlib_jll v1.3.1+2 [8e850b90] libblastrampoline_jll v5.13.1+0 Info Packages marked with ⌅ have new versions available but compatibility constraints restrict them from upgrading. Testing Running tests... Test Summary: | Pass Total Time Test small residual checks TrunkSolverNLS | 2 2 40.8s Test Summary: | Pass Total Time Test small residual checks TronSolverNLS | 2 2 7.0s Test Summary: | Pass Total Time Test iteration limit | 7 7 44.1s Test Summary: | Pass Total Time Test unbounded below | 10 10 6.4s Test Summary: | Pass Total Time Test restart with a different initial guess: R2 | 4 4 2.3s Test Summary: | Pass Total Time Test restart with a different initial guess: fomo | 4 4 5.7s 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.0s Test Summary: | Pass Total Time Test restart with a different initial guess: trunk | 4 4 1.2s Test Summary: | Pass Total Time Test restart NLS with a different initial guess: tron | 4 4 4.4s Test Summary: | Pass Total Time Test restart NLS with a different initial guess: trunk | 4 4 1.6s Test Summary: | Pass Total Time Test restart with a different problem: R2 | 4 4 2.0s Test Summary: | Pass Total Time Test restart with a different problem: fomo | 4 4 0.1s 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.2s 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.6s 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.6s Test Summary: | Pass Total Time Test callback for NLS | 2 2 8.2s Test Summary: | Pass Total Time Testing Solver Values | 1 1 2.6s Test Summary: | Pass Total Time Consistency | 36 36 43.7s 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=0x0000000000009958, method_table=Base.Compiler.CachedMethodTable{Base.Compiler.InternalMethodTable}(cache=Base.IdDict{Base.Compiler.MethodMatchKey, Union{Nothing, Base.Compiler.MethodLookupResult}}(ht=Memory{Any}(131072, 0x6451280)[ #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Any, SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Fix{1, F, T} where T where F}, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLPModel{Float64, Array{Float64, 1}, Array{Int64, 1}}, Array{Int64, 1}, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632de86c1e0)[Core.MethodMatch(spec_types=Tuple{Type{Base.Fix{1, F, T} where T where F}, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLPModel{Float64, Array{Float64, 1}, Array{Int64, 1}}, Array{Int64, 1}, Int64}}, 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=0x0000000000000c74, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LinearOperators.get_nargs), RipQP.var"#PreconditionerData##10#PreconditionerData##11"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e1b67640)[Core.MethodMatch(spec_types=Tuple{typeof(LinearOperators.get_nargs), RipQP.var"#PreconditionerData##10#PreconditionerData##11"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real}, sparams=svec(), method=get_nargs(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Tuple{Union{Char, String, Symbol}, String, String, String, Union{Char, String, Symbol}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ea61c860)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Tuple{Union{Char, String, Symbol}, String, String, String, Union{Char, String, Symbol}}, Int64}, sparams=svec(), method=iterate(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006a3, 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, 0x7632caed5080)[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=0x00000000000098c6, 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<:AbstractArray{T, 1} where T<:Real, NLPModels.Counters, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cad1c1e0)[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 where M1 where S<:AbstractArray{T, 1} where T<:Real, sparams=svec(T<:Real, S<:AbstractArray{T<:Real, 1}, M1, M2), 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=0x00000000000098de, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Base.Broadcast.Unknown, Nothing, typeof(LinearOperators.storage_type), var"#s185"} where var"#s185"<: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}(4, 0x7632e98a3720)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Base.Broadcast.Unknown, Nothing, typeof(LinearOperators.storage_type), var"#s185"} where var"#s185"<: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=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=0x0000000000004945, 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}, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cbe78040)[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}, 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=0x00000000000048f4, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), Tuple{typeof(DataType)}}, typeof(LinearOperators.CompositeLinearOperator), Any, Any, Any, Bool, Bool, LinearOperators.var"#hcat##0#hcat##1"{var"#s185", 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"#s185"<:LinearOperators.AbstractLinearOperator{T} where T, LinearOperators.var"#hcat##2#hcat##3"{var"#s185", 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"#s185"<:LinearOperators.AbstractLinearOperator{T} where T, LinearOperators.var"#hcat##4#hcat##5"{var"#s185", 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"#s185"<:LinearOperators.AbstractLinearOperator{T} where T, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bb8f7660)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), Tuple{typeof(DataType)}}, typeof(LinearOperators.CompositeLinearOperator), Type, I, I, Bool, Bool, F, Ft, Fct, Bool} where Fct<:(LinearOperators.var"#hcat##4#hcat##5"{var"#s185", 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"#s185"<:LinearOperators.AbstractLinearOperator{T} where T) where Ft<:(LinearOperators.var"#hcat##2#hcat##3"{var"#s185", 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"#s185"<:LinearOperators.AbstractLinearOperator{T} where T) where F<:(LinearOperators.var"#hcat##0#hcat##1"{var"#s185", 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"#s185"<:LinearOperators.AbstractLinearOperator{T} where T) where I<:Integer, sparams=svec(I<:I<:Integer, F<:F<:(LinearOperators.var"#hcat##0#hcat##1"{var"#s185", 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"#s185"<:LinearOperators.AbstractLinearOperator{T} where T), Ft<:Ft<:(LinearOperators.var"#hcat##2#hcat##3"{var"#s185", 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"#s185"<:LinearOperators.AbstractLinearOperator{T} where T), Fct<:Fct<:(LinearOperators.var"#hcat##4#hcat##5"{var"#s185", 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"#s185"<:LinearOperators.AbstractLinearOperator{T} 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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.string), String, Type{T} where T<:Real, String, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632baa4ad00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.string), String, Type{T} where T<:Real, String, Any}, sparams=svec(), method=string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003ea3, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._reindexlinear), Base.SubArray{Tf, 1, Array{Tf, 1}, Tuple{Base.UnitRange{Int64}}, true} where Tf<:Real, Base.UnitRange{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b8de5740)[Core.MethodMatch(spec_types=Tuple{typeof(Base._reindexlinear), Base.SubArray{Tf, 1, Array{Tf, 1}, Tuple{Base.UnitRange{Int64}}, true} where Tf<:Real, Base.UnitRange{Int64}}, sparams=svec(), method=_reindexlinear(Base.SubArray{T, N, P, I, true} where I<:Union{Tuple{Vararg{Real}}, Tuple{Base.AbstractUnitRange{T} where T, Vararg{Any}}} where P where N where T, Base.AbstractUnitRange{Int64}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002eb3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Float64}, Float64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e02b2b60)[Core.MethodMatch(spec_types=Tuple{Type{Float64}, Float64}, sparams=svec(Float64), method=(::Type{T})(T) where {T<:Number}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000235, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseArrays.LibSuiteSparse.cholmod_factorize_p), SparseArrays.CHOLMOD.Sparse{Float64, Int32}, Array{Float64, 1}, Ptr{Nothing}, Int64, SparseArrays.CHOLMOD.Factor{Float64, Int32}, Ref{SparseArrays.LibSuiteSparse.cholmod_common_struct}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e00ad740)[Core.MethodMatch(spec_types=Tuple{typeof(SparseArrays.LibSuiteSparse.cholmod_factorize_p), SparseArrays.CHOLMOD.Sparse{Float64, Int32}, Array{Float64, 1}, Ptr{Nothing}, Int64, SparseArrays.CHOLMOD.Factor{Float64, Int32}, Ref{SparseArrays.LibSuiteSparse.cholmod_common_struct}}, sparams=svec(), method=cholmod_factorize_p(Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000980f, 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, 0x7632de1e22e0)[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=0x00000000000048f4, 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(SparseMatricesCOO.replace_if_minusinf)}, LinearAlgebra.Adjoint{T, S} where S where T, Any}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632de250a80)[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(SparseMatricesCOO.replace_if_minusinf)}, LinearAlgebra.Adjoint{T, S} where S where T, Any}, 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=0x00000000000048f4, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Type{SparseArrays.LibSuiteSparse.cholmod_common_struct}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ecb6ea60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Type{SparseArrays.LibSuiteSparse.cholmod_common_struct}, Symbol}, sparams=svec(), method=getproperty(Type, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000299, 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, 0x7632b68cd320)[ 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=0x0000000000000a6a, 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, Float64}, limit=3), nothing, #, #, #, #, #, #, #, #, 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, 0x7632cd42aba0)[ 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=0x00000000000010f2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Tuple{String, Nothing, Vararg{Any}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dfe46ae0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Tuple{String, Nothing, Vararg{Any}}, Int64}, sparams=svec(), method=getindex(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_typejoin), Type, Type}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632d9f18140)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_typejoin), Type, Type}, sparams=svec(), method=promote_typejoin(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000060c, 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"#s185"} where var"#s185"<:RipQP.FactorizationData{Tlow} where Tlow<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b5a5d8e0)[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"#s185"} where var"#s185"<: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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._splatmap), typeof(Base.dataids), Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632df3fb0a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base._splatmap), typeof(Base.dataids), Tuple{}}, sparams=svec(), method=_splatmap(Any, Tuple{}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base._splatmap), typeof(Base.dataids), Tuple}, sparams=svec(), method=_splatmap(Any, Tuple), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002e5f, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LDLFactorizations.ldl_analyze), LinearAlgebra.Symmetric{Float64, SparseArrays.SparseMatrixCSC{Float64, Int64}}, Type{Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cc99a0a0)[Core.MethodMatch(spec_types=Tuple{typeof(LDLFactorizations.ldl_analyze), LinearAlgebra.Symmetric{Float64, SparseArrays.SparseMatrixCSC{Float64, Int64}}, Type{Float64}}, sparams=svec(Float64, Int64, Float64), method=ldl_analyze(LinearAlgebra.Symmetric{T, SparseArrays.SparseMatrixCSC{T, Ti}}, Type{Tf}) where {T<:Number, Ti<:Integer, Tf<:Number}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009900, 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, 0x7632cb2cc2c0)[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{Type{BoundsError}, FillArrays.Zeros{_A, 1, Tuple{Base.OneTo{Int64}}} where _A, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632de0ab720)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, FillArrays.Zeros{_A, 1, Tuple{Base.OneTo{Int64}}} 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{RipQP.var"##fd_refinement#117", Bool, typeof(RipQP.fd_refinement), 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, Array{T, 1} where T<:Real, RipQP.Point{T, S} where S where T<:Real, RipQP.IterData{T, S} where S where T<:Real, RipQP.Tolerances{T} where T<:Real, RipQP.DescentDirectionAllocs{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.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, 0x7632dce87c80)[Core.MethodMatch(spec_types=Tuple{RipQP.var"##fd_refinement#117", Bool, typeof(RipQP.fd_refinement), 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, 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.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.StartingPointData{T, S} where S, RipQP.Counters, Symbol} where T<:Real, sparams=svec(T<:Real), 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=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(-)), ForwardDiff.Partials{_A, Float64} where _A, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(0,), mem=Memory{Any}(0, 0x7632f6b091d0)[]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000000, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#cvt1#convert##0"{var"#s181", var"#s185"} where var"#s185"<:Tuple{AbstractArray{var"#s682", 1} where var"#s682", AbstractArray{var"#s682", 1} where var"#s682"} where var"#s181"<:Tuple{AbstractArray{var"#s682", 1} where var"#s682", AbstractArray{var"#s682", 1} where var"#s682"}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632decee5c0)[Core.MethodMatch(spec_types=Tuple{Base.var"#cvt1#convert##0"{var"#s181", var"#s185"} where var"#s185"<:Tuple{AbstractArray{var"#s682", 1} where var"#s682", AbstractArray{var"#s682", 1} where var"#s682"} where var"#s181"<:Tuple{AbstractArray{var"#s682", 1} where var"#s682", AbstractArray{var"#s682", 1} where var"#s682"}, Int64}, sparams=svec(var"#s181"<:Tuple{AbstractArray{var"#s682", 1} where var"#s682", AbstractArray{var"#s682", 1} where var"#s682"}), method=(::Base.var"#cvt1#convert##0"{T, x})(Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000398, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._prechecked_iterate), Any}, limit=3), nothing, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{ForwardDiff.Chunk{N} where N}, Array{Float64, 1}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cb9fa000)[Core.MethodMatch(spec_types=Tuple{Type{ForwardDiff.Chunk{N} where N}, Array{Float64, 1}, Int64}, sparams=svec(), method=(::Type{ForwardDiff.Chunk{N} where N})(AbstractArray{T, N} where N where T, Integer), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009830, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._cshp), Int64, Tuple{}, Tuple, Tuple{}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(9, 0x7632bb68db80)[ Core.MethodMatch(spec_types=Tuple{typeof(Base._cshp), Int64, Tuple{}, Tuple{}, Tuple{}}, sparams=svec(), method=_cshp(Int64, Tuple{}, Tuple{}, Tuple{}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base._cshp), Int64, Tuple{}, Tuple, Tuple{}}, sparams=svec(), method=_cshp(Int64, Tuple{}, Any, Tuple{}), fully_covers=true), #, #, #, #, #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000013db, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.argtail), Any, Any, Vararg{Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bb6a2040)[Core.MethodMatch(spec_types=Tuple{typeof(Base.argtail), Any, Any, Vararg{Any}}, sparams=svec(), method=argtail(Any, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000037b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Dict{K, V} where V where K}, Tuple{Pair{Symbol, Int64}, Vararg{Pair{A, B} where B where A}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632de7af200)[Core.MethodMatch(spec_types=Tuple{Type{Base.Dict{K, V} where V where K}, Tuple{Pair{Symbol, Int64}, Vararg{Pair{A, B} where B where A}}}, sparams=svec(), method=(::Type{Base.Dict{K, V} where V where K})(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000359c, 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, 0x7632ec0b4f20)[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{Type{BoundsError}, Memory{Union{Char, Integer, Tuple{Integer, Integer}}}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ca90f040)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Memory{Union{Char, Integer, Tuple{Integer, Integer}}}, 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.broadcastable), LinearAlgebra.Adjoint{T, var"#s185"} where var"#s185"<:AbstractArray{T, 1} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632de490a60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcastable), LinearAlgebra.Adjoint{T, var"#s185"} where var"#s185"<:AbstractArray{T, 1} where T<:Real}, sparams=svec(), method=broadcastable(Union{AbstractChar, Number, Tuple, Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, AbstractArray{T, N} where N where T, Ref{T} where T}), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000049e6, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.reshape), Base.BitArray{N} where N, Any}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ADNLPModels.get_c), ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T, ADNLPModels.ADBackend}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632e0605a60)[ Core.MethodMatch(spec_types=Tuple{typeof(ADNLPModels.get_c), ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T, ADNLPModels.InPlaceADbackend}, sparams=svec(), method=get_c(Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, ADNLPModels.InPlaceADbackend), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(ADNLPModels.get_c), ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T, ADNLPModels.ADBackend}, sparams=svec(), method=get_c(Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, ADNLPModels.ADBackend), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000984c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{ForwardDiff.Dual{_A, V, N} where N where V} where _A, Any, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ed0c9aa0)[Core.MethodMatch(spec_types=Tuple{Type{ForwardDiff.Dual{_A, V, N} where N where V} where _A, Any, Bool}, sparams=svec(_A), method=(::Type{ForwardDiff.Dual{T, V, N} where N where V})(Any, Any, Any...) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009830, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.axes), Base.Generator{Base.UnitRange{Int64}, F} where F<:(Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##2#__cat_offset1!##3"{Tuple{Bool, Bool}, var"#s185", 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 where var"#s185"<:Tuple)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cb1cffa0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.axes), Base.Generator{Base.UnitRange{Int64}, F} where F<:(Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##2#__cat_offset1!##3"{Tuple{Bool, Bool}, var"#s185", 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 where var"#s185"<:Tuple)}, sparams=svec(), method=axes(Base.Generator{I, F} where F where I), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000044f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s181"} where var"#s181"<:(RipQP.var"#PreconditionerData##16#PreconditionerData##17"{var"#s185"} where var"#s185"<:RipQP.FactorizationData{Tlow} where Tlow<:Real), RipQP.var"#PreconditionerData##16#PreconditionerData##17"{var"#s185"} where var"#s185"<:RipQP.FactorizationData{Tlow} where Tlow<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632dc1a8aa0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, RipQP.var"#PreconditionerData##16#PreconditionerData##17"{var"#s185"} where var"#s185"<: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##16#PreconditionerData##17"{var"#s185"} where var"#s185"<:RipQP.FactorizationData{Tlow} where Tlow<:Real} where T<:(RipQP.var"#PreconditionerData##16#PreconditionerData##17"{var"#s185"} where var"#s185"<: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=0x000000000000036c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{NamedTuple{(:context,), T} where T<:Tuple}, Tuple{Pair{Symbol, Bool}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b64dee40)[Core.MethodMatch(spec_types=Tuple{Type{NamedTuple{(:context,), T} where T<:Tuple}, Tuple{Pair{Symbol, Bool}}}, sparams=svec((:context,)), method=(::Type{NamedTuple{names, T} where T<:Tuple})(Tuple) where {names}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000019a, 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, 0x7632ea9405e0)[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=0x00000000000006a3, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.in), Array{T, 1} where T, Base.KeySet{Any, Base.IdDict{Any, Any}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632cdf38ca0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.in), Array{T, 1} where T, Base.KeySet{Any, Base.IdDict{Any, Any}}}, sparams=svec(), method=in(Any, Base.KeySet{var"#s185", var"#s184"} where var"#s184"<:(Base.IdDict{K, V} where V where K) where var"#s185"), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000017f2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), SparseArrays.HigherOrderFns.PromoteToSparse, typeof(SparseMatricesCOO.replace_if_minusinf), LinearAlgebra.Adjoint{Float64, var"#s185"} where var"#s185"<:AbstractArray{Float64, 1}, Float64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632dcd769e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), SparseArrays.HigherOrderFns.PromoteToSparse, typeof(SparseMatricesCOO.replace_if_minusinf), LinearAlgebra.Adjoint{Float64, var"#s185"} where var"#s185"<: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=0x0000000000004a9e, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.update_data!), RipQP.Point{Float64, S} where S<:AbstractArray{T, 1} where T<:Real, Any, Any, RipQP.IterData{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.AbstractResiduals{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}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632acbb5160)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.update_data!), RipQP.Point{Float64, S} where S<:AbstractArray{T, 1} where T<:Real, Float64, Float64, RipQP.IterData{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.AbstractResiduals{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}, sparams=svec(Float64), method=update_data!(RipQP.Point{T, S} where S, T, T, RipQP.IterData{T, S} where S, RipQP.PreallocatedData{T, S} where S, RipQP.AbstractResiduals{T, S} where S, RipQP.QM_FloatData_ref{T, S, M1, M2} where M2 where M1 where S, RipQP.QM_IntData) where {T<:Real}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.convert_mat), AbstractArray{T0, 2} where T0, Type{T} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632cb903420)[ Core.MethodMatch(spec_types=Tuple{typeof(RipQP.convert_mat), Union{SparseArrays.SparseMatrixCSC{Tv, Ti} where Ti<:Integer where Tv, SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv}, Type{T}} where T<:Real, sparams=svec(T<:Real), method=convert_mat(Union{SparseArrays.SparseMatrixCSC{Tv, Ti} where Ti<:Integer where Tv, SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv}, Type{T}) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(RipQP.convert_mat), Array{T, 2} where T, Type{T}} where T<:Real, sparams=svec(T<:Real), method=convert_mat(Array{T, 2} where T, Type{T}) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s181"} where var"#s181"<:Base.RefValue{typeof(Base.:(var"=="))}, Base.RefValue{typeof(Base.:(var"=="))}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632e0702120)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Base.RefValue{typeof(Base.:(var"=="))}}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Base.RefValue{typeof(Base.:(var"=="))}}, Base.RefValue{typeof(Base.:(var"=="))}}, sparams=svec(Base.RefValue{typeof(Base.:(var"=="))}), method=convert(Type{T}, T) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000036c, 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##4#PreconditionerData##5"{var"#s185"} where var"#s185"<:RipQP.FactorizationData{Tlow} where Tlow<:Real, Nothing, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b6cf7280)[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##4#PreconditionerData##5"{var"#s185"} where var"#s185"<: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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Expr}, Symbol, Symbol, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b781dbc0)[Core.MethodMatch(spec_types=Tuple{Type{Expr}, Symbol, Symbol, Any}, 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(Base.getproperty), Type{Array{Base.Rational{Int64}, 1}}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ed5a18a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Type{Array{Base.Rational{Int64}, 1}}, Symbol}, sparams=svec(), method=getproperty(Type, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000299, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.BottomRF{T} where T}, typeof(Base.min)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bab428c0)[Core.MethodMatch(spec_types=Tuple{Type{Base.BottomRF{T} where T}, typeof(Base.min)}, sparams=svec(typeof(Base.min)), method=(::Type{Base.BottomRF{T} where T})(T) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000032be, 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, 0x7632d9f7cce0)[ 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=0x0000000000001149, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.to_indices), Array{T, 1} where T<:Real, Tuple{Base.OneTo{Int64}}, Tuple{Array{Int64, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b81a16a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.to_indices), Array{T, 1} where T<:Real, Tuple{Base.OneTo{Int64}}, Tuple{Array{Int64, 1}}}, sparams=svec(), method=to_indices(Any, Any, Tuple{Any, Vararg}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000100c, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), Array{T, 1} where T<:Real, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R<:Real, Array{R, 1} where R<:Real}}, limit=1), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632ea19ad60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.copyto!), Array{T, 1} where T<:Real, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R<:Real, Array{R, 1} where R<:Real}}, 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=0x0000000000004a08, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.BroadcastStyle}, Type{Base.RefValue{typeof(Base.min)}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e18f6120)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.BroadcastStyle}, Type{Base.RefValue{typeof(Base.min)}}}, sparams=svec(Base.RefValue{typeof(Base.min)}), method=(::Type{Base.Broadcast.BroadcastStyle})(Type{T}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048de, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Nothing, _A, typeof(SparseMatricesCOO.replace_if_minusinf), var"#s185"} where var"#s185"<:Tuple where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632db114360)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Nothing, _A, typeof(SparseMatricesCOO.replace_if_minusinf), var"#s185"} where var"#s185"<: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=0x0000000000004945, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(QuadraticModels.empty_rows!), QuadraticModels.QuadraticModelPresolveData{T, S} where S where T, 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, 0x7632b5f61000)[Core.MethodMatch(spec_types=Tuple{typeof(QuadraticModels.empty_rows!), QuadraticModels.QuadraticModelPresolveData{T, S}, Array{QuadraticModels.PresolveOperation{T, S}, 1}} where S where T<:Real, sparams=svec(T<:Real, S), method=empty_rows!(QuadraticModels.QuadraticModelPresolveData{T, S}, Array{QuadraticModels.PresolveOperation{T, S}, 1}) where {T, S}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000098de, 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, 0x7632eaa993e0)[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=0x00000000000006a2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LinearOperators.get_nargs), RipQP.var"#PreconditionerData##16#PreconditionerData##17"{var"#s185"} where var"#s185"<:RipQP.FactorizationData{Tlow} where Tlow<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632eb3acd80)[Core.MethodMatch(spec_types=Tuple{typeof(LinearOperators.get_nargs), RipQP.var"#PreconditionerData##16#PreconditionerData##17"{var"#s185"} where var"#s185"<:RipQP.FactorizationData{Tlow} where Tlow<:Real}, sparams=svec(), method=get_nargs(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._any_tuple), Base.var"#TupleOrBottom##0#TupleOrBottom##1", Bool, Any, Type}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632da2fcb60)[Core.MethodMatch(spec_types=Tuple{typeof(Base._any_tuple), Base.var"#TupleOrBottom##0#TupleOrBottom##1", Bool, Any, Type}, sparams=svec(), method=_any_tuple(Any, Any, Any, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001b23, 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##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, 0x7632ea0b8d40)[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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Int64}, Signed}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632eba09420)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Int64}, Int64}, sparams=svec(Int64), method=convert(Type{T}, T) where {T<:Number}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Int64}, Signed}, sparams=svec(Int64), method=convert(Type{T}, Number) where {T<:Number}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000a6a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_result), Type, Type{Tuple{String, typeof(JSOSolvers.fomo)}}, Any, Type{Union{}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632db6b06e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_result), Type{T}, Type{Tuple{String, typeof(JSOSolvers.fomo)}}, Type{Union{}}, Type{Union{}}} where T, sparams=svec(T, Tuple{String, typeof(JSOSolvers.fomo)}), 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, typeof(JSOSolvers.fomo)}}, 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=0x000000000000062b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Array{_A, 1} where _A, Base.UnitRange{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e134b8e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Array{_A, 1} where _A, 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=0x00000000000012af, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Base.SubString{T} where T<:AbstractString, Base.UnitRange{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ccc99080)[Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Base.SubString{T} where T<:AbstractString, Base.UnitRange{Int64}}, sparams=svec(), method=checkbounds(AbstractString, Union{Integer, AbstractArray{T, N} where N where T}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003781, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eltype), Tuple{Pair{Symbol, Nothing}, Pair{Symbol, Array{QuadraticModels.PresolveOperation{T, _A}, 1}} where _A where T<:Real}}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ad38de80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.eltype), Tuple{Pair{Symbol, Nothing}, Pair{Symbol, Array{QuadraticModels.PresolveOperation{T, _A}, 1}} where _A where T<:Real}}, sparams=svec(), method=eltype(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000127a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{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 S where T}, RipQP.Point{T, var"#s185"} where var"#s185"<:AbstractArray{T, 1} where T<:Real where T<:Real, Union{RipQP.Residuals{T, var"#s185"} where var"#s185"<:AbstractArray{T, 1} where T<:Real where T<:Real, RipQP.ResidualsHistory{T, var"#s185"} where var"#s185"<: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}, Union{RipQP.DescentDirectionAllocsIPF{T, _A} where _A where T<:Real, RipQP.DescentDirectionAllocsPC{_A, S} where S<:(AbstractArray{T, 1} where T) where _A<:Real}, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632caca6140)[Core.MethodMatch(spec_types=Tuple{Type{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 S where T}, RipQP.Point{T, S}, Union{Res, Res}, Union{RipQP.IterDataCPU{T, S}, RipQP.IterDataGPU{T, S}}, Union{Dda, Dda}, Union{Pad, Pad}} where Pad<:RipQP.PreallocatedData{T, S} where Dda<:Union{RipQP.DescentDirectionAllocsIPF{T, S}, RipQP.DescentDirectionAllocsPC{T, S}} where Res<:Union{RipQP.Residuals{T, S}, RipQP.ResidualsHistory{T, S}} where Pad<:RipQP.PreallocatedData{T, S} where Dda<:Union{RipQP.DescentDirectionAllocsIPF{T, S}, RipQP.DescentDirectionAllocsPC{T, S}} where Res<:Union{RipQP.Residuals{T, S}, RipQP.ResidualsHistory{T, S}} where S<:AbstractArray{T, 1} where T<:Real where T<:Real, sparams=svec(T<:Real, S<:AbstractArray{T<:Real, 1}, Res<:RipQP.AbstractResiduals{T, S}, Dda<:RipQP.DescentDirectionAllocs{T, S}, Pad<:RipQP.PreallocatedData{T, S}), method=(::Type{RipQP.PreallocatedFloatData{T, S, Res, Dda, Pad} where Pad where Dda where Res where S where T})(RipQP.Point{T, S}, Res, RipQP.IterData{T, S}, Dda, Pad) where {T, S, Res<:RipQP.AbstractResiduals{T, S}, Dda<:RipQP.DescentDirectionAllocs{T, S}, Pad<:RipQP.PreallocatedData{T, S}}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._getindex), Base.IndexCartesian, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, typeof(Base.abs), var"#s185"} where var"#s185"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real)}, Base.IteratorsMD.CartesianIndex{2}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632de1ffb40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._getindex), Base.IndexCartesian, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, typeof(Base.abs), var"#s185"} where var"#s185"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real)}, Base.IteratorsMD.CartesianIndex{2}}, sparams=svec(), method=_getindex(Base.IndexStyle, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000049c2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), Array{QuadraticModels.Row{T}, 1} where T, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ae085e00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), Array{QuadraticModels.Row{T}, 1} where T, Int64}, sparams=svec(), method=size(Array{T, N} where N where T, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010c0, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._broadcast_getindex_eltype), Array{_A, 2} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dfd9f980)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._broadcast_getindex_eltype), Array{_A, 2} where _A}, sparams=svec(), method=_broadcast_getindex_eltype(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000049eb, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.rewrap_unionall), Any, Type{var"#s185"} where var"#s185"<: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=(2,), mem=Memory{Any}(4, 0x7632defc4a60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.rewrap_unionall), Core.TypeofVararg, Type{var"#s185"} where var"#s185"<: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=rewrap_unionall(Core.TypeofVararg, Any), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.rewrap_unionall), Any, Type{var"#s185"} where var"#s185"<: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=rewrap_unionall(Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000383, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IdDict{Any, Any}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cbb98ae0)[Core.MethodMatch(spec_types=Tuple{Type{Base.IdDict{Any, Any}}}, sparams=svec(Any, Any), method=(::Type{Base.IdDict{K, V}})() where {K, V}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000017cf, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.mightalias), Base.SubArray{_A, _B, P, I, false} 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, 0x7632ad7b7060)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.mightalias), Base.SubArray{_A, _B, P, I, false} 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=0x0000000000001352, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Type{LinearOperators.var"#119#120"}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ca063ea0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Type{LinearOperators.var"#119#120"}, Symbol}, sparams=svec(), method=getproperty(Type, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000299, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), Any, Any, Vararg{Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632e1d178a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), Any, Any}, sparams=svec(), method=combine_styles(Any, Any), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), Any, Any, Vararg{Any}}, sparams=svec(), method=combine_styles(Any, Any, Any...), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004975, 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, 0x7632de54a8a0)[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=0x000000000000980f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:show_time, :x0), Tuple{Bool, Array{Float64, 1}}}, Any, Int64, SolverTest.var"#53#54"{Int64}, Int64, ADNLPModels.var"#3#4"}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.to_indices), LinearAlgebra.Symmetric{Float64, S} where S<:(AbstractArray{var"#s4715", 2} where var"#s4715"<:Float64), Tuple}, limit=3), nothing, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LDLFactorizations.ldl_factorize!), LinearAlgebra.Symmetric{T, _B} where _B<:AbstractArray{T, 2} where T<:Real, LDLFactorizations.LDLFactorization{Tlow, Int64, Int64, Int64} where Tlow<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632dbeb43a0)[ Core.MethodMatch(spec_types=Tuple{typeof(LDLFactorizations.ldl_factorize!), LinearAlgebra.Symmetric{T, SparseArrays.SparseMatrixCSC{T, Int64}}, LDLFactorizations.LDLFactorization{Tf, Int64, Int64, Int64}} where Tf<:Real where T<:Real, sparams=svec(T<:Real, Tf<:Real, Int64, Int64, Int64), method=ldl_factorize!(LinearAlgebra.Symmetric{T, SparseArrays.SparseMatrixCSC{T, Ti}}, LDLFactorizations.LDLFactorization{Tf, Ti, Tn, Tp}) where {T<:Number, Tf<:Number, Ti<:Integer, Tn<:Integer, Tp<:Integer}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(LDLFactorizations.ldl_factorize!), LinearAlgebra.Symmetric{T, Array{T, 2}}, LDLFactorizations.LDLFactorization{Tlow, Int64, Int64, Int64} where Tlow<:Real} where T<:Real, sparams=svec(T<:Real), method=ldl_factorize!(LinearAlgebra.Symmetric{T, Array{T, 2}}, LDLFactorizations.LDLFactorization{T, Ti, Tn, Tp} where Tp<:Integer where Tn<:Integer where Ti<:Integer where T<:Number) where {T<:Number}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009900, 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"#51#52"{Int64}, 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, 0x7632b972da60)[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"#51#52"{Int64}, 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=0x000000000000984c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Generator{I, F} where F where I}, Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}, Base.Generator{Array{Int64, 1}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLPModel{Float64, Array{Float64, 1}, Array{Int64, 1}}, Array{Int64, 1}, Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632de8d2720)[Core.MethodMatch(spec_types=Tuple{Type{Base.Generator{I, F} where F where I}, Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}, Base.Generator{Array{Int64, 1}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLPModel{Float64, Array{Float64, 1}, Array{Int64, 1}}, Array{Int64, 1}, Int64}}}, sparams=svec(Base.Generator{Array{Int64, 1}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLPModel{Float64, Array{Float64, 1}, Array{Int64, 1}}, Array{Int64, 1}, Int64}}, Base.var"#_bool##0#_bool##1"{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=0x0000000000000440, 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{Float64, 1}, Array{Float64, 1}}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ba3d3900)[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{Float64, 1}, Array{Float64, 1}}, 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=0x00000000000048f4, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{NamedTuple{(:S,), T} where T<:Tuple}, Tuple{typeof(DataType)}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bb8f6a20)[Core.MethodMatch(spec_types=Tuple{Type{NamedTuple{(:S,), T} where T<:Tuple}, Tuple{typeof(DataType)}}, sparams=svec((:S,)), method=(::Type{NamedTuple{names, T} where T<:Tuple})(Tuple) where {names}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000019a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), Array{_A, 1} where _A, Float32, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632ba4e9f60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Array{Any, 1}, Float32, Int64}, sparams=svec(), method=setindex!(Array{Any, N} where N, Any, Int64), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Array{_A, 1} where _A, Float32, Int64}, sparams=svec(_A), method=setindex!(Array{T, N} where N, Any, Int64) where {T}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001149, 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, 0x7632bb739ba0)[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=0x000000000000037d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcastable), Array{T, N} where N where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632cd12d620)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcastable), Array{T, N} where N where T}, sparams=svec(), method=broadcastable(Union{AbstractChar, Number, Tuple, Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, AbstractArray{T, N} where N where T, Ref{T} where T}), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000049e6, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Tuple{String, Any, String, Int64, String, Nothing, String, Nothing, String, String, String}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e01d7d20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Tuple{String, Any, String, Int64, String, Nothing, String, Nothing, String, String, String}}, sparams=svec(), method=iterate(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006a2, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unsafe_convert), Type{Int32}, Int32}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e1f1e160)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_convert), Type{Int32}, Int32}, sparams=svec(Int32), method=unsafe_convert(Type{T}, T) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000003a6, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core._typeof_captured_variable), Tuple{Base.RefValue{typeof(Base.:(<=))}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dea2aae0)[Core.MethodMatch(spec_types=Tuple{typeof(Core._typeof_captured_variable), Tuple{Base.RefValue{typeof(Base.:(<=))}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N 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(Core.kwcall), NamedTuple{(:S,), var"#s185"} where var"#s185"<: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##6#PreconditionerData##7"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}, Nothing, Nothing, Int64, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cd7fe4c0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), var"#s185"} where var"#s185"<: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##6#PreconditionerData##7"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}, Nothing, Nothing, Int64, Int64, Int64}, sparams=svec(T<:Real, Int64, F<:(RipQP.var"#PreconditionerData##6#PreconditionerData##7"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}), 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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:max_cgiter, :max_time, :subsolver_verbose), Tuple{Int64, Float64, Int64}}, typeof(JSOSolvers.projected_newton!), 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, AbstractArray{T, 1} where T, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T, AbstractArray{T, 1} where T, Any, Any, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T, Any, AbstractArray{T, 1} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632af5d6780)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:max_cgiter, :max_time, :subsolver_verbose), Tuple{Int64, Float64, Int64}}, typeof(JSOSolvers.projected_newton!), 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}, AbstractArray{T, 1}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T, AbstractArray{T, 1}, Real, Real, AbstractArray{T, 1}, AbstractArray{T, 1}, AbstractArray{T, 1}, AbstractArray{T, 1}} where T<:Real, sparams=svec(T<:Real), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(JSOSolvers.projected_newton!), JSOSolvers.TronSolver{T, V, Sub, Op, Aop} where Aop<:LinearOperators.AbstractLinearOperator{T} where Op<:LinearOperators.AbstractLinearOperator{T} where Sub<:Krylov.KrylovWorkspace{T, T, V} where V<:AbstractArray{T, 1}, AbstractArray{T, 1}, Union{AbstractArray{T, 2} where T, LinearOperators.AbstractLinearOperator{T} where T}, AbstractArray{T, 1}, T, T, AbstractArray{T, 1}, AbstractArray{T, 1}, AbstractArray{T, 1}, AbstractArray{T, 1}) where {T<:Real}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009861, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#cvt1#convert##0"{I, var"#s185"} where var"#s185"<:Tuple{Real, Int64} where I<:Tuple{Real, Int64}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ba12f860)[Core.MethodMatch(spec_types=Tuple{Base.var"#cvt1#convert##0"{I, var"#s185"} where var"#s185"<:Tuple{Real, Int64} where I<:Tuple{Real, Int64}, Int64}, sparams=svec(I<:Tuple{Real, Int64}), method=(::Base.var"#cvt1#convert##0"{T, x})(Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000398, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{RipQP.StartingPointData{_A, _B}} where _B where _A, Any, Any, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ca37d6a0)[Core.MethodMatch(spec_types=Tuple{Type{RipQP.StartingPointData{T, S}} where S where T<:Real, Any, Any, Any}, sparams=svec(), method=(::Type{RipQP.StartingPointData{T<:Real, S}})(Any, Any, Any), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.maybeconstructor), 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, 0x7632eab1f840)[Core.MethodMatch(spec_types=Tuple{typeof(Base.maybeconstructor), 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=maybeconstructor(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c65, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LinearOperators.get_nargs), RipQP.var"#PreconditionerData##16#PreconditionerData##17"{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, 0x7632de34b880)[Core.MethodMatch(spec_types=Tuple{typeof(LinearOperators.get_nargs), RipQP.var"#PreconditionerData##16#PreconditionerData##17"{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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IndexStyle}, Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.sqrt), Tuple{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, 0x7632e1cc1360)[ Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.sqrt), Tuple{Base.Broadcast.Extruded{Array{Float64, 1}, Tuple{Bool}, Tuple{Int64}}}}}}, sparams=svec(), method=(::Type{Base.IndexStyle})(Type{var"#s683"} where var"#s683"<:(Base.Broadcast.Broadcasted{var"#s682", var"#s681", F, Args} where Args<:Tuple where F where var"#s681"<:Tuple{Any} where var"#s682")), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000492c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.update_IterData!), RipQP.IterData{Float64, S} where S, RipQP.Point{Float64, S} where S, 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, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632baa01ac0)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.update_IterData!), RipQP.IterData{Float64, S} where S, RipQP.Point{Float64, S} where S, 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, Bool}, sparams=svec(), method=update_IterData!(Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Array{ForwardDiff.Dual{T, Float64, _A}, 1}} where _A where T<:(ForwardDiff.Tag{_A, Float64} where _A), UndefInitializer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ca7a1660)[Core.MethodMatch(spec_types=Tuple{Type{Array{ForwardDiff.Dual{T, Float64, _A}, 1}} where _A where T<:(ForwardDiff.Tag{_A, Float64} where _A), UndefInitializer, Int64}, sparams=svec(T<:(ForwardDiff.Dual{T, Float64, _A} where T<:(ForwardDiff.Tag{_A, Float64} where _A) where _A)), method=(::Type{Array{T, 1}})(UndefInitializer, Int64) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000117, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{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(OperatorScaling.return_one_if_zero), Tuple{Base.Broadcast.Broadcasted{var"#s185", Nothing, typeof(Base.sqrt), var"#s185"} where var"#s185"<:Tuple{AbstractArray{T, 1} where Float64<:T<:Real} where var"#s185"<:Base.Broadcast.BroadcastStyle}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dcaa4360)[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(OperatorScaling.return_one_if_zero), Tuple{Base.Broadcast.Broadcasted{var"#s185", Nothing, typeof(Base.sqrt), var"#s185"} where var"#s185"<:Tuple{AbstractArray{T, 1} where Float64<:T<:Real} where var"#s185"<:Base.Broadcast.BroadcastStyle}}, sparams=svec(typeof(OperatorScaling.return_one_if_zero)), 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=0x00000000000048f3, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), Any, 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{var"#s185", Nothing, typeof(Base.identity), var"#s185"} where var"#s185"<:Tuple{AbstractArray{Float64, 1}} where var"#s185"<:Base.Broadcast.BroadcastStyle}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b819a860)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.Broadcast.BroadcastStyle, 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{var"#s185", Nothing, typeof(Base.identity), var"#s185"} where var"#s185"<:Tuple{AbstractArray{Float64, 1}} where var"#s185"<:Base.Broadcast.BroadcastStyle}, sparams=svec(), method=materialize!(Base.Broadcast.BroadcastStyle, Any, Base.Broadcast.Broadcasted{var"#s683", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s683"), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a03, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.transpose), Real}, limit=3), nothing, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Ptr{Nothing}}, Ptr{Ptr{Nothing}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ec1a2d60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Ptr{Nothing}}, Ptr{Ptr{Nothing}}}, sparams=svec(Nothing), method=convert(Type{Ptr{T}}, Ptr{T} where T) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000ca5, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), RipQP.Regularization{T0} where T0<:Union{Float32, Float64}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632d9de3780)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), RipQP.Regularization{T0} where T0<:Union{Float32, Float64}, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000029f, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{SparseArrays.CHOLMOD.var"##ldlt!#18", Float64, Bool, typeof(LinearAlgebra.ldlt!), SparseArrays.CHOLMOD.Factor{Float64, Ti} where Ti<:Union{Int32, Int64}, LinearAlgebra.Symmetric{Float64, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e1f47ac0)[Core.MethodMatch(spec_types=Tuple{SparseArrays.CHOLMOD.var"##ldlt!#18", Float64, Bool, typeof(LinearAlgebra.ldlt!), SparseArrays.CHOLMOD.Factor{Float64, Ti} where Ti<:Union{Int32, Int64}, LinearAlgebra.Symmetric{Float64, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, sparams=svec(Float64, Int64), method=var"#ldlt!#18"(Any, Bool, typeof(LinearAlgebra.ldlt!), SparseArrays.CHOLMOD.Factor{Tv, Ti} where Ti<:Union{Int32, Int64} where Tv<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}, Union{SparseArrays.SparseMatrixCSC{T, Ti}, SparseArrays.SparseMatrixCSC{Base.Complex{T}, Ti}, LinearAlgebra.Hermitian{Base.Complex{T}, var"#s418"} where var"#s418"<:SparseArrays.SparseMatrixCSC{Base.Complex{T}, Ti}, LinearAlgebra.Hermitian{T, var"#s417"} where var"#s417"<:SparseArrays.SparseMatrixCSC{T, Ti}, LinearAlgebra.Symmetric{T, var"#s419"} where var"#s419"<:SparseArrays.SparseMatrixCSC{T, Ti}}) where {T<:Real, Ti}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000980f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.imag), var"#s185"} where var"#s185"<:Tuple{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, 0x7632ae2a1760)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.imag), var"#s185"} where var"#s185"<:Tuple{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=0x000000000000029f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.typeintersect), Type{Tuple{Any, Any}}, Type{var"#s181"} where var"#s181"<: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, 0x7632dc62e660)[Core.MethodMatch(spec_types=Tuple{typeof(Base.typeintersect), Type{Tuple{Any, Any}}, Type{var"#s181"} where var"#s181"<: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=typeintersect(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000547, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(var"==")), AbstractArray{T, 1} where T, AbstractArray{T, 1} where T}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.mapfoldl_impl), typeof(Base.identity), 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, 0x7632eb689fc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.mapfoldl_impl), typeof(Base.identity), 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(typeof(Base.identity), typeof(Base.min)), method=mapfoldl_impl(F, OP, Any, Any) where {F, OP}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000032b3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Any, Type, Vararg{Any}}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s181"} where var"#s181"<:Tuple{Base.RefValue{typeof(SparseMatricesCOO.replace_if_minusinf)}, AbstractArray{T, N} where N where T, Int64}, Tuple{Base.RefValue{typeof(SparseMatricesCOO.replace_if_minusinf)}, AbstractArray{T, N} where N where T, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7632cd800d20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Tuple{Base.RefValue{typeof(SparseMatricesCOO.replace_if_minusinf)}, AbstractArray{T, N} where N where T, Int64}}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, Tuple{Base.RefValue{typeof(SparseMatricesCOO.replace_if_minusinf)}, AbstractArray{T, N} where N where T, Int64}} where T<:Tuple{Base.RefValue{typeof(SparseMatricesCOO.replace_if_minusinf)}, AbstractArray{T, N} where N where T, Int64}, 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"#s181"} where var"#s181"<:Tuple{Base.RefValue{typeof(SparseMatricesCOO.replace_if_minusinf)}, AbstractArray{T, N} where N where T, Int64}, Tuple{Base.RefValue{typeof(SparseMatricesCOO.replace_if_minusinf)}, AbstractArray{T, N} where N where T, Int64}}, sparams=svec(3, var"#s181"<:Tuple{Base.RefValue{typeof(SparseMatricesCOO.replace_if_minusinf)}, AbstractArray{T, N} where N where T, Int64}), method=convert(Type{T}, Tuple{Vararg{Any, N}}) where {N, T<:Tuple}, fully_covers=true), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000399, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{NamedTuple{(:x0, :nnzh, :minimize, :islp, :name), T} where T<:Tuple}, Tuple{Any, Any, Bool, Bool, String}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bb9a9400)[Core.MethodMatch(spec_types=Tuple{Type{NamedTuple{(:x0, :nnzh, :minimize, :islp, :name), T} where T<:Tuple}, Tuple{Any, Any, Bool, Bool, String}}, sparams=svec((:x0, :nnzh, :minimize, :islp, :name)), method=(::Type{NamedTuple{names, T} where T<:Tuple})(Tuple) where {names}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000019a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.preprocess), Array{_A, 2} where _A, Array{_A, 2} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cbd7f420)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.preprocess), Array{_A, 2} where _A, Array{_A, 2} where _A}, sparams=svec(), method=preprocess(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a0f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Tf} where Tf<:Number, Number}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.dotgetproperty), 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}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b77c6be0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.dotgetproperty), 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}, Symbol}, sparams=svec(), method=dotgetproperty(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000002a2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Array{T, 1} where Float64<:T<:Real, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ea548600)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Array{T, 1} where Float64<: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=0x00000000000003bb, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.dataids), Array{_A, 2} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632da41f3c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.dataids), Array{_A, 2} where _A}, sparams=svec(), method=dataids(Array{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001361, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseArrays._setindex_scalar!), SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv<:Real, Any, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e0ebafe0)[Core.MethodMatch(spec_types=Tuple{typeof(SparseArrays._setindex_scalar!), SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv<:Real, Any, Int64, Int64}, sparams=svec(Tv<:Real, Int64), method=_setindex_scalar!(SparseArrays.AbstractSparseMatrixCSC{Tv, Ti}, Any, Integer, Integer) where {Tv, Ti<:Integer}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000980f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isbits), Array{_A, 2} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632da41da20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.isbits), Array{_A, 2} where _A}, sparams=svec(), method=isbits(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000525, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), 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, 0x7632da9ae7a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), 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=0x000000000000029f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Base.Generator{Base.UnitRange{Int64}, F} where F<:(Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##0#__cat_offset1!##1"{var"#s185", Tuple{Bool, Bool}, Tuple{Vararg{Int64, N}}, _A}} where _A where N where var"#s185"<:Tuple{Any, Any, Vararg{Int64}}), Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632caae4aa0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Base.Generator{Base.UnitRange{Int64}, F} where F<:(Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##0#__cat_offset1!##1"{var"#s185", Tuple{Bool, Bool}, Tuple{Vararg{Int64, N}}, _A}} where _A where N where var"#s185"<:Tuple{Any, Any, Vararg{Int64}}), Int64}, sparams=svec(), method=iterate(Base.Generator{I, F} where F where I, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000044b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{ForwardDiff.Dual{Nothing, Float64, _A}} where _A, Float64, ForwardDiff.Partials{N, Float64} where N}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ca395aa0)[Core.MethodMatch(spec_types=Tuple{Type{ForwardDiff.Dual{Nothing, Float64, N}}, Float64, ForwardDiff.Partials{N, Float64}} where N, sparams=svec(Nothing, Float64, N), method=(::Type{ForwardDiff.Dual{T, V, N}})(V, ForwardDiff.Partials{N, V}) where {T, V, N}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009830, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.length), SparseArrays.SparseVector{T, Int64} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ccb7d5a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.length), SparseArrays.SparseVector{T, Int64} where T<:Real}, sparams=svec(), method=length(SparseArrays.SparseVector{Tv, Ti} where Ti<:Integer where Tv), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000980f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{LinearOperators.var"##_#1", 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, 0x7632ea0bb5c0)[Core.MethodMatch(spec_types=Tuple{LinearOperators.var"##_#1", 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=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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.dotgetproperty), SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cbe90700)[Core.MethodMatch(spec_types=Tuple{typeof(Base.dotgetproperty), SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv, Symbol}, sparams=svec(), method=dotgetproperty(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000002a2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s181"} where var"#s181"<:Tuple{Base.RefValue{typeof(Base.:(<))}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T}, Tuple{Base.RefValue{typeof(Base.:(<))}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7632d924ff20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Tuple{Base.RefValue{typeof(Base.:(<))}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T}}, 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.:(<))}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T}} where T<:Tuple{Base.RefValue{typeof(Base.:(<))}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T}, 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"#s181"} where var"#s181"<:Tuple{Base.RefValue{typeof(Base.:(<))}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T}, Tuple{Base.RefValue{typeof(Base.:(<))}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T}}, sparams=svec(3, var"#s181"<:Tuple{Base.RefValue{typeof(Base.:(<))}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T}), method=convert(Type{T}, Tuple{Vararg{Any, N}}) where {N, T<:Tuple}, fully_covers=true), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000399, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#cvt1#convert##0"{var"#s181", var"#s185"} where var"#s185"<:Tuple{Base.RefValue{typeof(Base.:(*))}, Any, Array{T, N} where N where T} where var"#s181"<: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, 0x7632caff1a20)[Core.MethodMatch(spec_types=Tuple{Base.var"#cvt1#convert##0"{var"#s181", var"#s185"} where var"#s185"<:Tuple{Base.RefValue{typeof(Base.:(*))}, Any, Array{T, N} where N where T} where var"#s181"<:Tuple{Base.RefValue{typeof(Base.:(*))}, Any, Array{T, N} where N where T}, Int64}, sparams=svec(var"#s181"<: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=0x0000000000000398, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:x0,), Tuple{Array{Float64, 1}}}, Any, Int64, SolverTest.var"#47#48", Int64, ADNLPModels.var"#3#4"}, 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.sqrt), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real)}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b79c7a00)[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.sqrt), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real)}, Nothing}, 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=0x00000000000048f4, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eachindex), Base.IndexLinear, Base.AbstractUnitRange{T} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632cc89bca0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), Base.IndexLinear, Base.AbstractUnitRange{T} where T}, sparams=svec(), method=eachindex(Base.IndexLinear, AbstractArray{T, 1} where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000128e, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.argtail), 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, 0x7632d9df2c40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.argtail), Int64, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, sparams=svec(), method=argtail(Any, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000037b, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#cvt1#convert##0"{var"#s181", var"#s185"} where var"#s185"<:Tuple{Base.Broadcast.Broadcasted{var"#s185", Nothing, typeof(Base.sqrt), var"#s185"} where var"#s185"<:Tuple{AbstractArray{T, 1} where Float64<:T<:Real} where var"#s185"<:Base.Broadcast.BroadcastStyle} where var"#s181"<:Tuple{Base.Broadcast.Broadcasted{var"#s185", Nothing, typeof(Base.sqrt), var"#s185"} where var"#s185"<:Tuple{AbstractArray{T, 1} where Float64<:T<:Real} where var"#s185"<:Base.Broadcast.BroadcastStyle}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dcbbfda0)[Core.MethodMatch(spec_types=Tuple{Base.var"#cvt1#convert##0"{var"#s181", var"#s185"} where var"#s185"<:Tuple{Base.Broadcast.Broadcasted{var"#s185", Nothing, typeof(Base.sqrt), var"#s185"} where var"#s185"<:Tuple{AbstractArray{T, 1} where Float64<:T<:Real} where var"#s185"<:Base.Broadcast.BroadcastStyle} where var"#s181"<:Tuple{Base.Broadcast.Broadcasted{var"#s185", Nothing, typeof(Base.sqrt), var"#s185"} where var"#s185"<:Tuple{AbstractArray{T, 1} where Float64<:T<:Real} where var"#s185"<:Base.Broadcast.BroadcastStyle}, Int64}, sparams=svec(var"#s181"<:Tuple{Base.Broadcast.Broadcasted{var"#s185", Nothing, typeof(Base.sqrt), var"#s185"} where var"#s185"<:Tuple{AbstractArray{T, 1} where Float64<:T<:Real} where var"#s185"<:Base.Broadcast.BroadcastStyle}), method=(::Base.var"#cvt1#convert##0"{T, x})(Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000398, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Type{Array{var"#s4715", 1}} where var"#s4715"<:Float64, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b8c2a020)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Type{Array{var"#s4715", 1}} where var"#s4715"<:Float64, Symbol}, sparams=svec(), method=getproperty(Type, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000299, 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"#s185"} where var"#s185"<: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, 0x7632bb043100)[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"#s185"} where var"#s185"<: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=0x00000000000006ae, 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, 0x7632eb9954e0)[ 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=0x0000000000005b0e, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{S} where S<:AbstractArray{Float64, 1}, UndefInitializer, Int64}, limit=3), nothing, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.preprocess), Array{T, 1} where T<:Real, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.sqrt), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R<:Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b79b7940)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.preprocess), Array{T, 1} where T<:Real, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.sqrt), var"#s185"} where var"#s185"<: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=0x0000000000004a0e, 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.:(>)), var"#s185"} where var"#s185"<: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, 0x7632db16ac80)[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.:(>)), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R, Array{R, 1} where R}}, sparams=svec(Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s185"<:Tuple{Array{R, 1} where R, Array{R, 1} where R}), method=convert(Type{Base.Broadcast.Broadcasted{NewStyle, Axes, F, Args} where Args<:Tuple where F where Axes}, Base.Broadcast.Broadcasted{var"#s683", Axes, F, Args} where var"#s683") where {NewStyle, Axes, F, Args}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004913, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Float64}, Real}, limit=3), nothing, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eachindex), 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, 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}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dbcf1160)[Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), 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, 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=eachindex(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001282, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_typejoin), Type{Symbol}, typeof(DataType)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dea95800)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_typejoin), Type{Symbol}, typeof(DataType)}, sparams=svec(), method=promote_typejoin(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000060c, 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, 0x7632cb87d760)[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=0x00000000000002a0, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.methods), RipQP.var"#PreconditionerData##16#PreconditionerData##17"{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, 0x7632de370880)[Core.MethodMatch(spec_types=Tuple{typeof(Base.methods), RipQP.var"#PreconditionerData##16#PreconditionerData##17"{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=methods(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000005a0, 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{T, N} where N where T, Any}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cd6836e0)[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{T, N} where N where T, Any}, 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=0x00000000000048f4, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.rdims), Base.Val{1}, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632d9369c60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.rdims), Base.Val{1}, Tuple{StaticArrays.SOneTo{n} where n, Vararg{StaticArrays.SOneTo{n} where n}}}, sparams=svec(1), method=rdims(Base.Val{N}, Tuple{StaticArrays.SOneTo{n} where n, Vararg{StaticArrays.SOneTo{n} where n}}) where {N}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.rdims), Base.Val{1}, Tuple}, sparams=svec(1), method=rdims(Base.Val{N}, Tuple) where {N}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009838, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(var"==")), var"#s185"} where var"#s185"<: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, 0x7632ba709c90)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(var"==")), Union{}}, Int64}, sparams=svec(T, S), method=_broadcast_getindex(Base.Broadcast.Broadcasted{var"#s683", var"#s682", var"#s681", var"#s680"} where var"#s680"<:Tuple{Ref{Type{T}}, Ref{Type{S}}, Vararg{Any}} where var"#s681" where var"#s682" where var"#s683", Any) where {T, S}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(var"==")), var"#s185"} where var"#s185"<: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"#s683", var"#s682", var"#s681", var"#s680"} where var"#s680" where var"#s681" where var"#s682" where var"#s683", Any), fully_covers=true), #, #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000049dd, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.RefValue{Int32}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cbb3bbc0)[Core.MethodMatch(spec_types=Tuple{Type{Base.RefValue{Int32}}, Int64}, sparams=svec(Int32), method=(::Type{Base.RefValue{T}})(Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000cf4, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.axes), Base.AbstractRange{Union{}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dca89d80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.axes), Base.AbstractRange{Union{}}}, sparams=svec(), method=axes(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000125e, 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.imag), var"#s185"} where var"#s185"<: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, 0x7632ae35fd20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.axes), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.imag), var"#s185"} where var"#s185"<:Tuple{Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64}}}, 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=0x000000000000491a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._insert!), Array{T, 1} where T<:Real, Int64, Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e05340a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._insert!), Array{T, 1}, Int64, Real} where T<:Real, sparams=svec(T), method=_insert!(Array{T, 1}, Integer, T) where {T}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000011a2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.pointer), SparseArrays.CHOLMOD.Factor{Tv, Ti} where Ti<:Union{Int32, 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, 0x7632b53b25e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.pointer), SparseArrays.CHOLMOD.Factor{Tv, Ti} where Ti<:Union{Int32, 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=pointer(SparseArrays.CHOLMOD.Factor{Tv, Ti} where Ti<:Union{Int32, Int64}) where {Tv}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000980f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.abs), var"#s185"} where var"#s185"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real)}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dc0c8980)[Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.abs), var"#s185"} where var"#s185"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<: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=0x00000000000049ca, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._iterate), LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4715", 2} where var"#s4715"<:T) where T, Tuple{Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632af183fc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._iterate), LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4715", 2} where var"#s4715"<:T) where T, Tuple{Any}}, sparams=svec(), method=_iterate(AbstractArray{T, N} where N where T, Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001302, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s181"} where var"#s181"<:Tuple, Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7632df9d9da0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Tuple}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, T} where T<:Tuple, 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"#s181"} where var"#s181"<:Tuple, Tuple}, sparams=svec(Vararg, var"#s181"<:Tuple), method=convert(Type{T}, Tuple{Vararg{Any, N}}) where {N, T<:Tuple}, fully_covers=true), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000399, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.kwerr), NamedTuple{names, T} where T<:Tuple where names, Type{Krylov.GmresWorkspace{T, FC, S} where S where FC where T}, Integer, Integer, Type}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ec5fbda0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.kwerr), 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(4), method=kwerr(Any, Vararg{Any, N}) where {N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000009f6, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), Array{_A, 1} where _A, Integer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632eabeb960)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Array{Any, 1}, Integer, Int64}, sparams=svec(), method=setindex!(Array{Any, N} where N, Any, Int64), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Array{_A, 1} where _A, Integer, Int64}, sparams=svec(_A), method=setindex!(Array{T, N} where N, Any, Int64) where {T}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001149, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Tuple{AbstractArray{Float64, 1}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632de826b40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Tuple{AbstractArray{Float64, 1}}, Int64}, sparams=svec(), method=getindex(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.typejoin), Type{Bool}, Type{Bool}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632eabbe720)[Core.MethodMatch(spec_types=Tuple{typeof(Base.typejoin), Type{Bool}, Type{Bool}}, sparams=svec(), method=typejoin(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000608, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.typeintersect), Type{Tuple{Any, Any}}, Type{var"#s181"} where var"#s181"<: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)}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632da7e2500)[Core.MethodMatch(spec_types=Tuple{typeof(Base.typeintersect), Type{Tuple{Any, Any}}, Type{var"#s181"} where var"#s181"<: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)}}, sparams=svec(), method=typeintersect(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000547, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), Any, typeof(Base.:(&)), Any, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s181"} where var"#s181"<:Union{Float32, Float64}, Float64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(6, 0x7632b8681150)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Float64}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, Float64} where Float64<:T<:Union{Float32, Float64}, sparams=svec(Float64<: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"#s181"} where var"#s181"<:Union{Float32, Float64}, Float64}, sparams=svec(var"#s181"<:Union{Float32, Float64}), method=convert(Type{T}, Number) where {T<:Number}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000a6a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{QuadraticModels.var"#get_arows_acols##0#get_arows_acols##1"{_A, Array{Int64, 1}} where _A, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ba650440)[Core.MethodMatch(spec_types=Tuple{QuadraticModels.var"#get_arows_acols##0#get_arows_acols##1"{_A, Array{Int64, 1}} where _A, Int64}, sparams=svec(_A), method=(::QuadraticModels.var"#get_arows_acols##0#get_arows_acols##1"{T, row_cnt})(Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000098de, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), Any, Array{T, 1} where T}, limit=1), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), Array{T, 1} where Float64<:T<:Real, Any, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Base.Iterators.Zip{Is} where Is<:Tuple{Array{Int64, 1}, Array{T, 1} where T<:Real}, Tuple{Int64, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ad0238c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Base.Iterators.Zip{Is} where Is<:Tuple{Array{Int64, 1}, Array{T, 1} where T<:Real}, Tuple{Int64, Int64}}, sparams=svec(), method=iterate(Base.Iterators.Zip{Is} where Is<:Tuple, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001904, 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{Base.OneTo{Int64}}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632de3f4240)[Core.MethodMatch(spec_types=Tuple{Type{Tuple}, Base.Generator{Base.UnitRange{Int64}, Base.var"#ntuple##0#ntuple##1"{Base.Returns{Base.OneTo{Int64}}}}}, sparams=svec(Tuple), method=(::Type{T})(Any) where {T<:Tuple}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000070a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.TwicePrecision{T} where T, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b9c1c860)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.TwicePrecision{T} where T, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000029f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._growend!), Array{Tf, 1} where Tf<:Number, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cd202180)[Core.MethodMatch(spec_types=Tuple{typeof(Base._growend!), Array{Tf, 1} where Tf<:Number, Int64}, sparams=svec(), method=_growend!(Array{T, 1} where T, Integer), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000115f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IteratorsMD.CartesianIndices{1, Tuple{Base.StepRange{Int64, Int64}}}}, Tuple{Base.StepRange{Int64, Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632df1c9c20)[Core.MethodMatch(spec_types=Tuple{Type{Base.IteratorsMD.CartesianIndices{1, Tuple{Base.StepRange{Int64, Int64}}}}, Tuple{Base.StepRange{Int64, Int64}}}, sparams=svec(), method=(::Type{Base.IteratorsMD.CartesianIndices{N, R<:Tuple{Vararg{Base.OrdinalRange{Int64, Int64}, N}}}})(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000046f4, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), LinearAlgebra.Symmetric{T, SparseArrays.SparseMatrixCSC{T, Int64}} where T<:Number, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b771d7a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), LinearAlgebra.Symmetric{T, SparseArrays.SparseMatrixCSC{T, Int64}} where T<:Number, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000029f, 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}, var"#s185", typeof(Base.identity), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R} where var"#s185"<:Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632abd4f2a0)[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}, var"#s185", typeof(Base.identity), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R} where var"#s185"<:Tuple}, sparams=svec(Nothing, var"#s185"<:Tuple, typeof(Base.identity), var"#s185"<:Tuple{Array{R, 1} where R}), method=convert(Type{Base.Broadcast.Broadcasted{NewStyle, Axes, F, Args} where Args<:Tuple where F where Axes}, Base.Broadcast.Broadcasted{var"#s683", Axes, F, Args} where var"#s683") where {NewStyle, Axes, F, Args}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004913, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), AbstractArray{T, 1} where Float64<:T<:Real, Any}, limit=1), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), SparseArrays.SparseMatrixCSC{T, Ti} where Ti<:Integer where Float64<:T<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dba78420)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), SparseArrays.SparseMatrixCSC{T, Ti} where Ti<:Integer where Float64<:T<:Real, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000029f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LinearAlgebra.mul!), Any, AbstractArray{Float64, 2}, AbstractArray{Float64, 1}}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Any, typeof(DataType)}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.error_if_canonical_getindex), Base.IndexLinear, Array{_A, 1} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ad973aa0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.error_if_canonical_getindex), Base.IndexLinear, Array{_A, 1} where _A}, sparams=svec(), method=error_if_canonical_getindex(Base.IndexStyle, AbstractArray{T, N} where N where T, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000131a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{LinearAlgebra.UniformScaling{T} where T<:Number}, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632cd43d520)[ Core.MethodMatch(spec_types=Tuple{Type{LinearAlgebra.UniformScaling{T} where T<:Number}, ChainRulesCore.AbstractZero}, sparams=svec(), method=(::Type{var"#s11"<:(LinearAlgebra.UniformScaling{T} where T<:Number)})(ChainRulesCore.AbstractZero), fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{LinearAlgebra.UniformScaling{T} where T}, T} where T<:Number, sparams=svec(T<:Number), method=(::Type{LinearAlgebra.UniformScaling{T} where T})(T) where {T<:Number}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000983e, 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, 0x7632b5d964a0)[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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(*)), Any, FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632ccafb060)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(*)), Any, FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}}, sparams=svec(typeof(Base.:(*))), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a9d, 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.BitArray{1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<=)), Tuple{Array{Float64, 1}, Array{Float64, 1}}}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e095b8a0)[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.BitArray{1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<=)), Tuple{Array{Float64, 1}, Array{Float64, 1}}}}}}, sparams=svec(Nothing, 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}}}}), method=convert(Type{Base.Broadcast.Broadcasted{NewStyle, Axes, F, Args} where Args<:Tuple where F where Axes}, Base.Broadcast.Broadcasted{var"#s683", Axes, F, Args} where var"#s683") where {NewStyle, Axes, F, Args}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004913, 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, 0x7632cb886be0)[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=0x0000000000000bfb, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(/)), Any, 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.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e10dff60)[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{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, 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=0x00000000000048f4, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds_indices), Type{Bool}, Any, Tuple{Base.BitArray{N} where N}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632dc929960)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds_indices), Type{Bool}, Tuple, Tuple{Base.BitArray{N} where N}}, sparams=svec(), method=checkbounds_indices(Type{Bool}, Tuple, Tuple{AbstractArray{Bool, N} where N, Vararg}), fully_covers=false), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047df, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{RipQP.var"##RipQPTripleSolver#129", Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Type{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 where S where T}, QuadraticModels.QuadraticModel{T0, S0, M1, M2} where M2 where M1 where S0<:AbstractArray{T0, 1} where T0<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b8a3d300)[Core.MethodMatch(spec_types=Tuple{RipQP.var"##RipQPTripleSolver#129", RipQP.InputTol{T0, Int64}, Bool, Bool, I, Bool, Symbol, Bool, RipQP.RipQPTripleParameters{T0, SP1, SP2, SP3, SM1, SM2, SM3} where SM3<:RipQP.SolveMethod where SM2<:RipQP.SolveMethod where SM1<:RipQP.SolveMethod where SP3<:RipQP.SolverParams{T0} where SP2<:(RipQP.SolverParams{T} where T) where SP1<:(RipQP.SolverParams{T} where T), Bool, RipQP.SystemWrite, Bool, Type{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 where S where T}, QuadraticModels.QuadraticModel{T0, S0, M1, M2} where M2 where M1} where I<:Integer where S0<:AbstractArray{T0, 1} where T0<:Real, sparams=svec(T0<:Real, S0<:AbstractArray{T0<:Real, 1}, I<:I<:Integer), method=var"#RipQPTripleSolver#129"(RipQP.InputTol{T0, Int64}, Bool, Bool, I, Bool, Symbol, Bool, RipQP.RipQPTripleParameters{T0, SP1, SP2, SP3, SM1, SM2, SM3} where SM3<:RipQP.SolveMethod where SM2<:RipQP.SolveMethod where SM1<:RipQP.SolveMethod where SP3<:RipQP.SolverParams{T0} where SP2<:(RipQP.SolverParams{T} where T) where SP1<:(RipQP.SolverParams{T} where T), Bool, RipQP.SystemWrite, Bool, Type{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 where S where T}, QuadraticModels.AbstractQuadraticModel{T0, S0}) where {T0<:Real, S0<:AbstractArray{T0, 1}, I<:Integer}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.iszero)}, var"#s185"} where var"#s185"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool, Bool}, Tuple{Int64, Int64}} where T<:(Array{_A, 2} where _A)}, Base.IteratorsMD.CartesianIndex{2}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632da2ee3a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.iszero)}, var"#s185"} where var"#s185"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool, Bool}, Tuple{Int64, Int64}} where T<:(Array{_A, 2} where _A)}, Base.IteratorsMD.CartesianIndex{2}}, 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=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000049c9, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eltype), Type{S} where S<:(Array{_A, 1} where _A)}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(6, 0x7632bb0ebc20)[ 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{S} where S<:Array{E, 1}} where E, sparams=svec(E), method=eltype(Type{var"#s185"} where var"#s185"<:(AbstractArray{E, N} where N)) where {E}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.eltype), Type{S} where S<:(Array{_A, 1} where _A)}, sparams=svec(), method=eltype(Type), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000127b, 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{AbstractArray{T, 1} where T<:Real, Array{R, 1} where R<:Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b8d78d00)[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{AbstractArray{T, 1} where T<:Real, Array{R, 1} where R<: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=0x00000000000048f3, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), 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.abs), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632adcb7c20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), 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.abs), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R}}, sparams=svec(), method=combine_styles(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004974, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), Tuple{Any, Base.RefValue{T} where T, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632de7dcc20)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), Tuple{Any, Base.RefValue{T} where T, AbstractArray{T, N} where N where T, 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{Type{LinearAlgebra.Diagonal{T, V} where V<:AbstractArray{T, 1} where T}, Array{Tlow, 1} where Tlow<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dadd2cc0)[Core.MethodMatch(spec_types=Tuple{Type{LinearAlgebra.Diagonal{T, V} where V<:AbstractArray{T, 1} where T}, Array{Tlow, 1} where Tlow<:Real}, sparams=svec(Tlow<:Real), method=(::Type{LinearAlgebra.Diagonal{T, V} where V<:AbstractArray{T, 1} where T})(AbstractArray{T, 1}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000008c4d, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.axes), Base.Generator{Base.UnitRange{Int64}, F} where F<:(QuadraticModels.var"#get_arows_acols##0#get_arows_acols##1"{_A, Array{Int64, 1}} where _A)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ba6825e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.axes), Base.Generator{Base.UnitRange{Int64}, F} where F<:(QuadraticModels.var"#get_arows_acols##0#get_arows_acols##1"{_A, Array{Int64, 1}} where _A)}, sparams=svec(), method=axes(Base.Generator{I, F} where F where I), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000044f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.mightalias), Array{Tv, 1} where Tv, AbstractArray{T, N} where N where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632e00b8260)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.mightalias), Array{Tv, 1} where Tv, ForwardDiff.Partials{N, V} where V where N}, sparams=svec(), method=mightalias(AbstractArray{T, N} where N where T, ForwardDiff.Partials{N, V} where V where N), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.mightalias), Array{Tv, 1} where Tv, AbstractArray{T, N} where N where T}, 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=0x0000000000009830, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), Any, typeof(Base.:(+)), Any, AbstractArray{Float64, 1}}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._getindex), Base.IndexLinear, Array{_A, 1} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632ad9767e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base._getindex), Base.IndexLinear, Array{_A, 1} where _A}, sparams=svec(0), method=_getindex(Base.IndexLinear, AbstractArray{T, N} where N where T, Vararg{Int64, M}) where {M}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000131e, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), Base.ComposedFunction{Type{_A}, typeof(Base.:(-))} where _A, Array{R, 1} where R<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632d96a25e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Base.ComposedFunction{Type{_A}, typeof(Base.:(-))} where _A, Array{R, 1} where R<:Real}, sparams=svec(F<:(Base.ComposedFunction{Type{_A}, typeof(Base.:(-))} where _A)), method=broadcasted(F, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a9c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.cons!), 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, 0x7632ecaf74e0)[Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.cons!), ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T}, sparams=svec(), method=cons!(NLPModels.AbstractNLPModel{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=0x0000000000009849, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), Tuple{LinearAlgebra.Adjoint{T, var"#s185"} where var"#s185"<:AbstractArray{T, 1} where Float64<:T<:Real, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dcd29960)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), Tuple{LinearAlgebra.Adjoint{T, var"#s185"} where var"#s185"<:AbstractArray{T, 1} where Float64<:T<:Real, 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.diff_fallback), NamedTuple{(:x0,), var"#s185"} where var"#s185"<: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, 0x7632e1ee6460)[Core.MethodMatch(spec_types=Tuple{typeof(Base.diff_fallback), NamedTuple{(:x0,), var"#s185"} where var"#s185"<: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=0x0000000000001aff, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LinearOperators.get_nargs), RipQP.var"#PreconditionerData##6#PreconditionerData##7"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632db075c40)[Core.MethodMatch(spec_types=Tuple{typeof(LinearOperators.get_nargs), RipQP.var"#PreconditionerData##6#PreconditionerData##7"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real}, sparams=svec(), method=get_nargs(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.neval_cons), 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, 0x7632afc0ac40)[Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.neval_cons), ADNLPModels.ADNLPModel{T, V, Si} where Si where V<:AbstractArray{T, 1} where T}, sparams=svec(), method=neval_cons(NLPModels.AbstractNLPModel{T, S} where S where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009849, 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}, 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=(1,), mem=Memory{Any}(1, 0x7632dfdfd500)[Core.MethodMatch(spec_types=Tuple{typeof(Base.grow_to!), Base.Dict{K, V} where V where K, 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=grow_to!(Base.AbstractDict{K, V} where V where K, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000017c3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.rewrap_unionall), Any, Type{var"#s185"} where var"#s185"<:Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632b9d48be0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.rewrap_unionall), Core.TypeofVararg, Type{var"#s185"} where var"#s185"<:Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A}}, sparams=svec(), method=rewrap_unionall(Core.TypeofVararg, Any), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.rewrap_unionall), Any, Type{var"#s185"} where var"#s185"<:Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A}}, sparams=svec(), method=rewrap_unionall(Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000383, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Any, Base.Rational{Int64}}, limit=3), nothing, 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), Base.Colon}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dbe0b940)[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), Base.Colon}, sparams=svec(), method=_minimum(Any, Base.Colon), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000005b17, 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.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 _A where S where F where T where Tlow<:Real where T<:Real where T<:Real, Any, RipQP.Regularization{T} where T<:Real, 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, Any, Any, Bool, Bool, RipQP.LRPrecond{Op1, Op2} where Op2 where Op1}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632af5cdcc0)[Core.MethodMatch(spec_types=Tuple{Type{RipQP.LDLData{T, Array{T, 1}, Tlow, LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, S}, _A, 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 _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.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, Any, Any, Bool, Bool, RipQP.LRPrecond{Op1, Op2} where Op2 where Op1}, 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=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s181"} where var"#s181"<:(Array{T, 1} where T<:Number), Array{T, 1} where T<:Number}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632dbd355e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, 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{var"#s181"} where var"#s181"<:(Array{T, 1} where T<:Number), Array{T, 1} where T<:Number}, sparams=svec(var"#s181"<:(Array{T, 1} where T<: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=0x0000000000001111, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._promote_typesubtract), Type}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ed2c9b20)[Core.MethodMatch(spec_types=Tuple{typeof(Base._promote_typesubtract), Type}, sparams=svec(), method=_promote_typesubtract(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000060e, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(-)), Any, FillArrays.Fill{Float64, 1, Tuple{Base.OneTo{Int64}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632b8383b20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(-)), Any, FillArrays.Fill{Float64, 1, Tuple{Base.OneTo{Int64}}}}, sparams=svec(typeof(Base.:(-))), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a9d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{RipQP.PreallocatedDataK2LDL{T, S, F, M} where M<:AbstractArray{T, 2} where F where S where T<:Real}, Any, RipQP.Regularization{Float64}, Bool, Any, LinearAlgebra.Symmetric{Float64, SparseArrays.SparseMatrixCSC{Float64, Int64}}, RipQP.LDLFactorizationData{Float64}, Bool, Array{Int64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b9bf85c0)[Core.MethodMatch(spec_types=Tuple{Type{RipQP.PreallocatedDataK2LDL{T, S, F, M} where M<:AbstractArray{T, 2} where F where S where T<:Real}, S, RipQP.Regularization{Float64}, Bool, SparseArrays.SparseVector{Float64, Int64}, LinearAlgebra.Symmetric{Float64, SparseArrays.SparseMatrixCSC{Float64, Int64}}, RipQP.LDLFactorizationData{Float64}, Bool, Array{Int64, 1}} where S, sparams=svec(Float64, S<:S, RipQP.LDLFactorizationData{Float64}, SparseArrays.SparseMatrixCSC{Float64, Int64}), method=(::Type{RipQP.PreallocatedDataK2LDL{T, S, F, M} where M where F where S where T})(S, RipQP.Regularization{T}, Bool, SparseArrays.SparseVector{T, Int64}, LinearAlgebra.Symmetric{T, M}, F, Bool, Array{Int64, 1}) where {T<:Real, S, F, M<:AbstractArray{T, 2}}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, 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, 0x7632dc0f1360)[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=0x000000000000100b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseArrays.CHOLMOD.allocate_sparse), UInt64, UInt64, UInt64, Bool, Bool, Int32, Type{Tv} where Tv<:Union{Float32, Float64}, Type{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b9061480)[Core.MethodMatch(spec_types=Tuple{typeof(SparseArrays.CHOLMOD.allocate_sparse), UInt64, UInt64, UInt64, Bool, Bool, Int32, Type{Tv} where Tv<:Union{Float32, Float64}, Type{Int64}}, sparams=svec(Tv<:Union{Float32, Float64}), method=allocate_sparse(Integer, Integer, Integer, Bool, Bool, Integer, Type{Tv}, Type{Int64}) where {Tv<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000980f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.print_to_string), String, Any, String, Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dc2fd360)[Core.MethodMatch(spec_types=Tuple{typeof(Base.print_to_string), String, Any, String, Tuple}, sparams=svec(), method=print_to_string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003ea0, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._broadcast_getindex), 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, 0x7632b6513b00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Ti, 1} where Ti<:Integer), Int64}, sparams=svec(), method=_broadcast_getindex(Base.Broadcast.Extruded{T, K, D} where D where K where T, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000049d6, 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, 0x7632deae4a60)[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=0x00000000000010f1, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.length), Tuple{typeof(DataType), Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b8ed77a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.length), Tuple{typeof(DataType), Any}}, sparams=svec(), method=length(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000068c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.length), AbstractArray{Float64, 1}}, limit=3), nothing, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.index_ndims), Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7632e1aed860)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.index_ndims), AbstractArray{Base.IteratorsMD.CartesianIndex{N}, N} where N} where N, sparams=svec(N), method=index_ndims(AbstractArray{Base.IteratorsMD.CartesianIndex{N}, N} where N, Any...) where {N}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.index_ndims), Base.IteratorsMD.CartesianIndex{N} where N}, sparams=svec(), method=index_ndims(Base.IteratorsMD.CartesianIndex{N} where N, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.index_ndims), Any}, sparams=svec(), method=index_ndims(Any, Any...), fully_covers=true), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b9, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), Base.RefValue{typeof(Base.min)}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e18f4900)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), Base.RefValue{typeof(Base.min)}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T}, sparams=svec(), method=combine_styles(Any, Any, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004975, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{NamedTuple{(:ap,), T} where T<:Tuple}, 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}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ae50a080)[Core.MethodMatch(spec_types=Tuple{Type{NamedTuple{(:ap,), T} where T<:Tuple}, 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}}, sparams=svec((:ap,)), method=(::Type{NamedTuple{names, T} where T<:Tuple})(Tuple) where {names}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000019a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_type), 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, 0x7632e1856b80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_type), Type{Tuple{String, Function}}, Type{Tuple{String, typeof(JSOSolvers.tron)}}}, sparams=svec(Tuple{String, Function}, Tuple{String, typeof(JSOSolvers.tron)}), method=promote_type(Type{T}, Type{S}) where {T, S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000621, 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"#s185"} where var"#s185"<:Tuple{Array{Ti, 1} where Ti<:Integer, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b7175f20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.preprocess), Nothing, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(-)), var"#s185"} where var"#s185"<: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=0x0000000000004a0e, 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.min)}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bab1ce60)[Core.MethodMatch(spec_types=Tuple{Type{Base.MappingRF{F, T} where T where F}, typeof(LinearAlgebra.norm), Base.BottomRF{typeof(Base.min)}}, sparams=svec(typeof(LinearAlgebra.norm), Base.BottomRF{typeof(Base.min)}), 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=0x00000000000032c4, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), Any, AbstractArray{var"#s682", 1} where var"#s682"}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632df149860)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), Any, AbstractArray{var"#s682", 1} where var"#s682"}, sparams=svec(), method=combine_styles(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004974, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core._typeof_captured_variable), Base.BitArray{N} where N}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ec5e6080)[Core.MethodMatch(spec_types=Tuple{typeof(Core._typeof_captured_variable), Base.BitArray{N} where N}, 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.typeintersect), Type{Tuple{Any, Any}}, Type{var"#s181"} where var"#s181"<:Tuple{AbstractArray{Float64, 1}, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bb625bc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.typeintersect), Type{Tuple{Any, Any}}, Type{var"#s181"} where var"#s181"<:Tuple{AbstractArray{Float64, 1}, Float64}}, sparams=svec(), method=typeintersect(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000547, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(-)), var"#s185"} where var"#s185"<:Tuple{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, 0x7632b67c8460)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(-)), var"#s185"} where var"#s185"<:Tuple{Array{Ti, 1} where Ti<:Integer, Int64}, 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=0x000000000000491c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._tuple_error), Type{var"#s181"} where var"#s181"<:Tuple{Base.RefValue{typeof(Base.:(var"=="))}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T}, Tuple{Base.RefValue{typeof(Base.:(var"=="))}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632de2506a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._tuple_error), Type{var"#s181"} where var"#s181"<:Tuple{Base.RefValue{typeof(Base.:(var"=="))}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T}, Tuple{Base.RefValue{typeof(Base.:(var"=="))}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T}}, sparams=svec(), method=_tuple_error(Type, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000394, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), Array{T, 1} where T<:Real, Any, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632df7e5f60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Array{T, 1} where T<:Real, Any, Int64}, sparams=svec(T<:Real), method=setindex!(Array{T, N} where N, Any, Int64) where {T}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001149, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_eltypes), typeof(Base.:(>)), Tuple{Array{Int64, 1}, Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632de0ca0c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_eltypes), typeof(Base.:(>)), Tuple{Array{Int64, 1}, Real}}, sparams=svec(), method=combine_eltypes(Any, Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000049f2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.to_indices), 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}(4, 0x7632e02016e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.to_indices), Array{T, 1} where T<:Real, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}}, sparams=svec(), method=to_indices(Any, Tuple{Any}), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001007, 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<:Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632daf10ee0)[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<:Real}}, 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) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048f3, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.reduce_empty), typeof(Base.max), Type{Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632d925bec0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.reduce_empty), typeof(Base.max), Type{Any}}, sparams=svec(), method=reduce_empty(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003308, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.cconvert), Type{Ptr{SparseArrays.LibSuiteSparse.cholmod_sparse_struct}}, SparseArrays.CHOLMOD.Sparse{Tv, Int32} where Tv<:Union{Float32, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632cd4b7ae0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.cconvert), Type{Ptr{SparseArrays.LibSuiteSparse.cholmod_sparse_struct}}, SparseArrays.CHOLMOD.Sparse{Tv, Int32} where Tv<:Union{Float32, Float64}}, sparams=svec(), method=cconvert(Type{var"#s66"} where var"#s66"<:(Ptr{T} where T), Any), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000003a4, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s185"} where var"#s185"<: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, 0x7632b85c09e0)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s185"} where var"#s185"<: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{Type{SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T}, 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, 0x7632ec18ad60)[Core.MethodMatch(spec_types=Tuple{Type{SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T}, ADNLPModels.ADNLPModel{T, V, Si} where Si where V<:AbstractArray{T, 1} where T}, sparams=svec(T, V<:AbstractArray{T, 1}), method=(::Type{SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T})(NLPModels.AbstractNLPModel{T, S}) where {T, S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009856, 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, Int64, Any, Any, Any, Any, Any, Any, Any, Any, Any, Int64, Int64, Int64, Int64, Int64, Int64, Int64, Base.UnitRange{Int64}, Array{Int64, 1}, Bool, Bool, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ae357cc0)[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, Int64, Any, Any, Any, Any, Any, Any, Any, Any, Any, Int64, Int64, Int64, Int64, Int64, Int64, Int64, Base.UnitRange{Int64}, Array{Int64, 1}, 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=0x0000000000009849, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), var"#s185"} where var"#s185"<: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##6#PreconditionerData##7"{var"#s185"} where var"#s185"<:RipQP.FactorizationData{Tlow} where Tlow<:Real, Nothing, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b6153260)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), var"#s185"} where var"#s185"<: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##6#PreconditionerData##7"{var"#s185"} where var"#s185"<: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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#_bool##0#_bool##1"{typeof(SparseArrays._isnotzero)}, Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b7ce9720)[Core.MethodMatch(spec_types=Tuple{Base.var"#_bool##0#_bool##1"{typeof(SparseArrays._isnotzero)}, Real}, sparams=svec(), method=(::Base.var"#_bool##0#_bool##1"{f})(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003397, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s181"} where var"#s181"<: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)}, 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)}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7632cdb8c6a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, 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)}}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, 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)}} where T<: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)}, 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"#s181"} where var"#s181"<: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)}, 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)}}, sparams=svec(2, var"#s181"<: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)}), method=convert(Type{T}, Tuple{Vararg{Any, N}}) where {N, T<:Tuple}, fully_covers=true), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000399, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copy), Memory{_A} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e0149800)[Core.MethodMatch(spec_types=Tuple{typeof(Base.copy), Memory{_A} where _A}, sparams=svec(T<:(Memory{_A} where _A)), method=copy(T) where {T<:(Memory{T} where T)}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001076, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type, Bool}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{Krylov.var"##GmresWorkspace#41", Int64, Type{Krylov.GmresWorkspace{T, FC, S} where S where FC where T}, Integer, Integer, Type}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ec88bfa0)[Core.MethodMatch(spec_types=Tuple{Krylov.var"##GmresWorkspace#41", Int64, Type{Krylov.GmresWorkspace{T, FC, S} where S where FC where T}, Integer, Integer, Type}, sparams=svec(), method=var"#GmresWorkspace#41"(Integer, Type{Krylov.GmresWorkspace{T, FC, S} where S where FC where T}, Integer, Integer, Type), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000985f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), Base.var"#__cat_offset1!##2#__cat_offset1!##3"{Tuple{Bool, Bool}, var"#s185", 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 where var"#s185"<:Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cb18bce0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), Base.var"#__cat_offset1!##2#__cat_offset1!##3"{Tuple{Bool, Bool}, var"#s185", 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 where var"#s185"<:Tuple}, 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.to_indices), Array{T, 1} where T<:Number, Tuple{}, Tuple{}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632d9dfaf40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.to_indices), Array{T, 1} where T<:Number, Tuple{}, Tuple{}}, sparams=svec(), method=to_indices(Any, Any, Tuple{}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000100b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#cvt1#convert##0"{var"#s181", var"#s185"} where var"#s185"<:Tuple{Any, Float64} where var"#s181"<:Tuple{Any, Float64}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b7167000)[Core.MethodMatch(spec_types=Tuple{Base.var"#cvt1#convert##0"{var"#s181", var"#s185"} where var"#s185"<:Tuple{Any, Float64} where var"#s181"<:Tuple{Any, Float64}, Int64}, sparams=svec(var"#s181"<:Tuple{Any, Float64}), method=(::Base.var"#cvt1#convert##0"{T, x})(Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000398, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.tail), Tuple{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, 0x7632eac9ab60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.tail), Tuple{AbstractArray{T, 1} where T, AbstractArray{T, 1} where T}}, sparams=svec(), method=tail(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000037d, 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}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dbbb9f60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.methods), RipQP.var"#PreconditionerData##14#PreconditionerData##15"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real}, sparams=svec(), method=methods(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000005a0, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.diff_fallback), NamedTuple{(:display, :sp), var"#s185"} where var"#s185"<:Tuple{Bool, RipQP.K2LDLParams{_A, RipQP.LDLFact} where _A}, Tuple{Symbol, Symbol}, NTuple{7, Symbol}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cb2b1fe0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.diff_fallback), NamedTuple{(:display, :sp), var"#s185"} where var"#s185"<:Tuple{Bool, RipQP.K2LDLParams{_A, RipQP.LDLFact} where _A}, Tuple{Symbol, Symbol}, NTuple{7, 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=0x0000000000001aff, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcastable), LinearAlgebra.Adjoint{Float64, var"#s185"} where var"#s185"<:AbstractArray{Float64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632dd04cbe0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcastable), LinearAlgebra.Adjoint{Float64, var"#s185"} where var"#s185"<:AbstractArray{Float64, 1}}, sparams=svec(), method=broadcastable(Union{AbstractChar, Number, Tuple, Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, AbstractArray{T, N} where N where T, Ref{T} where T}), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000049e6, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), LinearAlgebra.Symmetric{T, var"#s44"} where var"#s44"<:AbstractArray{T, 2} where T, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632da9957e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), LinearAlgebra.Symmetric{T, var"#s44"} where var"#s44"<:AbstractArray{T, 2} where T, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000029f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(-)), AbstractArray{T, 1} where T, Array{Float64, 1}}, limit=3), nothing, #, #, #, #, #, #, #, #, 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, 0x7632de2782e0)[ 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"#s683"} where var"#s683"<:AbstractArray{T, N}) where {T, N}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048dd, 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, 0x7632eb820fa0)[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{Type{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632decf9c60)[Core.MethodMatch(spec_types=Tuple{Type{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, Int64, Int64}, sparams=svec(Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true), 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=0x0000000000002e42, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{Union{Array{T, 1} where T<:Real, ReverseDiff.TrackedArray{V, D, 1, VA, DA} where DA where VA where D where V}, ReverseDiff.var"#24#25"{Tuple{Int64}}}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b937d3c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{Union{Array{T, 1} where T<:Real, ReverseDiff.TrackedArray{V, D, 1, VA, DA} where DA where VA where D where V}, 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=0x00000000000006ae, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Base.Generator{I, LinearOperators.var"#141#142"} 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, 0x7632cdb39620)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Base.Generator{I, LinearOperators.var"#141#142"} 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=iterate(Base.Generator{I, F} where F where I, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000044b, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, 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##6#PreconditionerData##7"{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, 0x7632db061780)[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##6#PreconditionerData##7"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Nothing, Nothing, Int64, Int64, Int64}, sparams=svec(T<:Real, Int64, F<:(RipQP.var"#PreconditionerData##6#PreconditionerData##7"{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=0x0000000000009848, 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, 0x7632ca694400)[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=0x0000000000009906, 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, 0x7632dbd4e820)[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=0x00000000000010e4, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.nteltype), Type{NamedTuple{(:code, :input_size, :output_size, :input_delta, :output_delta), Tuple{Symbol, Vararg{Int64, 4}}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b9587b20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.nteltype), Type{NamedTuple{(:code, :input_size, :output_size, :input_delta, :output_delta), Tuple{Symbol, Vararg{Int64, 4}}}}}, sparams=svec(Tuple{Symbol, Vararg{Int64, 4}}), method=nteltype(Type{NamedTuple{names, T}} where names) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001ac9, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), Array{var"#s4715", 1} where var"#s4715"<:Real, Any, Any}, limit=3), nothing, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Type{Symbol}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bb4f5a40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Type{Symbol}, Symbol}, sparams=svec(Symbol), method=getindex(Type{T}, Any...) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010f1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Generator{I, F} where F where I}, Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}, 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, 0x7632ea649c60)[Core.MethodMatch(spec_types=Tuple{Type{Base.Generator{I, F} where F where I}, Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}, 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(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)), Base.var"#_bool##0#_bool##1"{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=0x0000000000000440, 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}, Base.Missing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bb724a60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators._zip_iterate_some), Tuple{AbstractArray{typeof(DataType), 1}}, Tuple{Tuple{}}, 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=0x0000000000001908, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.read), Base.AnnotatedIOBuffer, Type{Base.AnnotatedString{String}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b6544ae0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.read), Base.AnnotatedIOBuffer, Type{Base.AnnotatedString{String}}}, sparams=svec(String), method=read(Base.AnnotatedIOBuffer, Type{Base.AnnotatedString{T}}) where {T<:AbstractString}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003f20, 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, 0x7632cc7f5960)[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=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), Array{_A, 1} where _A, Array{Ti, 1} where Ti<:Integer, Base.UnitRange{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632ebd117e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Array{T, 1}, Array{T, 1}, Base.UnitRange{Int64}} where T<:Integer, sparams=svec(T<:Integer), method=setindex!(Array{T, N} where N, Array{T, N} where N, Base.AbstractUnitRange{Int64}) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Array{_A, 1} where _A, Array{Ti, 1} where Ti<:Integer, Base.UnitRange{Int64}}, sparams=svec(), method=setindex!(Array{T, N} where N where T, AbstractArray{T, N} where N where T, AbstractArray{Int64, 1}), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001152, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.CoreLogging.var"##handle_message_nothrow#2", Base.Pairs{Symbol, Any, NTuple{5, Symbol}, NamedTuple{(:code, :input_size, :output_size, :input_delta, :output_delta), Tuple{Symbol, Vararg{Int64, 4}}}}, 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, 0x7632b966dbc0)[Core.MethodMatch(spec_types=Tuple{Base.CoreLogging.var"##handle_message_nothrow#2", Base.Pairs{Symbol, Any, NTuple{5, Symbol}, NamedTuple{(:code, :input_size, :output_size, :input_delta, :output_delta), Tuple{Symbol, Vararg{Int64, 4}}}}, typeof(Base.CoreLogging.handle_message_nothrow), Base.CoreLogging.AbstractLogger, Base.CoreLogging.LogLevel, String, Module, Symbol, Symbol, String, Int64}, sparams=svec(), method=var"#handle_message_nothrow#2"(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.CoreLogging.handle_message_nothrow), Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000005039, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(!)), Any}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Array{Ti, 1} where Ti<:Integer, Type, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ca25be00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Array{Ti, 1} where Ti<:Integer, Type, Int64}, sparams=svec(T), method=similar(AbstractArray{T, N} where N where T, Type{T}, Union{Integer, Base.AbstractUnitRange{T} where T}...) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012c4, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.merge), NamedTuple{(:ap,), var"#s185"} where var"#s185"<:Tuple{RipQP.RipQPDoubleParameters{Float64, RipQP.K2LDLParams{Float64, RipQP.LDLFact}, _A, RipQP.PC, RipQP.PC} where _A<:RipQP.SolverParams{Float64}}, Base.Pairs{Symbol, Any, NTuple{4, Symbol}, NamedTuple{(:history, :scaling, :display, :mode), Tuple{Bool, Bool, Bool, Symbol}}}}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bb4e4c60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.merge), NamedTuple{(:ap,), var"#s185"} where var"#s185"<:Tuple{RipQP.RipQPDoubleParameters{Float64, RipQP.K2LDLParams{Float64, RipQP.LDLFact}, _A, RipQP.PC, RipQP.PC} where _A<:RipQP.SolverParams{Float64}}, Base.Pairs{Symbol, Any, NTuple{4, Symbol}, NamedTuple{(:history, :scaling, :display, :mode), Tuple{Bool, Bool, Bool, Symbol}}}}, sparams=svec(), method=merge(NamedTuple{names, T} where T<:Tuple where names, Base.Pairs{var"#s185", var"#s184", var"#s183", var"#s182"} where var"#s182"<:(NamedTuple{names, T} where T<:Tuple where names) where var"#s183" where var"#s184" where var"#s185"), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001aed, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Float64}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b70acf00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Float64}, Int64}, sparams=svec(Float64), method=convert(Type{T}, Number) where {T<:Number}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000a6a, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.__cat_offset1!), Any, Tuple{Any, Any, Vararg{Int64}}, Tuple{Bool, Bool}, Tuple{Vararg{Int64}}, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ca94c380)[Core.MethodMatch(spec_types=Tuple{typeof(Base.__cat_offset1!), Any, Tuple{Any, Any, Vararg{Int64}}, Tuple{Bool, Bool}, Tuple{Vararg{Int64}}, Any}, sparams=svec(), method=__cat_offset1!(Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000013f7, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.throw_boundserror), Array{T, 1} where T<:Number, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cd900520)[Core.MethodMatch(spec_types=Tuple{typeof(Base.throw_boundserror), Array{T, 1} where T<:Number, Tuple{Int64}}, sparams=svec(), method=throw_boundserror(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000032d, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(var"==")), Base.OneTo{Int64}, Any}, limit=3), nothing, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.to_index), Array{Ti, 1} where Ti<:Integer, Base.IteratorsMD.CartesianIndex{N} where N}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dc6bc120)[Core.MethodMatch(spec_types=Tuple{typeof(Base.to_index), Array{Ti, 1} where Ti<:Integer, Base.IteratorsMD.CartesianIndex{N} where N}, sparams=svec(), method=to_index(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000ffb, 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, 0x7632acd463a0)[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=0x00000000000006e2, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eachindex), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(OperatorScaling.return_one_if_zero), var"#s185"} where var"#s185"<:Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.sqrt), var"#s185"} where var"#s185"<: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, 0x7632b7d97860)[Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(OperatorScaling.return_one_if_zero), var"#s185"} where var"#s185"<:Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.sqrt), var"#s185"} where var"#s185"<: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=0x0000000000004925, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), Array{ForwardDiff.Dual{Tag, T, 1}, 1} where T where Tag, ForwardDiff.Dual{_A, Float64, 1} where _A, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632b9a3eb60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Array{ForwardDiff.Dual{Tag, T, 1}, 1} where T where Tag, ForwardDiff.Dual{_A, Float64, 1} where _A, Int64}, sparams=svec(T<:(ForwardDiff.Dual{Tag, T, 1} where Tag where T)), method=setindex!(Array{T, N} where N, Any, Int64) where {T}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001149, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.print_to_string), String, Type{Float64}, String, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cb459280)[Core.MethodMatch(spec_types=Tuple{typeof(Base.print_to_string), String, Type{Float64}, String, Any}, sparams=svec(), method=print_to_string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003ea0, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._tuple_error), Type{var"#s181"} where var"#s181"<:Tuple{Any, Base.RefValue{T} where T, LinearAlgebra.Adjoint{T, S} where S where T, Any}, Tuple{Any, Base.RefValue{T} where T, LinearAlgebra.Adjoint{T, S} where S where T, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632de6b1560)[Core.MethodMatch(spec_types=Tuple{typeof(Base._tuple_error), Type{var"#s181"} where var"#s181"<:Tuple{Any, Base.RefValue{T} where T, LinearAlgebra.Adjoint{T, S} where S where T, Any}, Tuple{Any, Base.RefValue{T} where T, LinearAlgebra.Adjoint{T, S} where S where T, Any}}, sparams=svec(), method=_tuple_error(Type, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000394, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:status, :solution, :objective, :dual_feas, :primal_feas, :multipliers, :multipliers_L, :multipliers_U, :iter, :elapsed_time, :solver_specific), var"#s185"} where var"#s185"<:Tuple{Symbol, Any, Float64, Float64, Float64, Any, Any, Any, Int64, Float64, Base.Dict{Symbol, Tsp} where Tsp}, 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, 0x7632bb237c80)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:status, :solution, :objective, :dual_feas, :primal_feas, :multipliers, :multipliers_L, :multipliers_U, :iter, :elapsed_time, :solver_specific), var"#s185"} where var"#s185"<:Tuple{Symbol, Any, Float64, Float64, Float64, Any, Any, Any, Int64, Float64, Base.Dict{Symbol, Tsp} where Tsp}, 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}), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, Type{SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T}, NLPModels.AbstractNLPModel{T, S}) where {T, S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009856, 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##18#PreconditionerData##19"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Nothing, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ec189460)[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##18#PreconditionerData##19"{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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.mapreduce_empty), Base.ComposedFunction{typeof(Base.float), typeof(LinearAlgebra.norm)}, Base.BottomRF{typeof(Base.:(+))}, Type{Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cb678d00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.mapreduce_empty), Base.ComposedFunction{typeof(Base.float), typeof(LinearAlgebra.norm)}, Base.BottomRF{typeof(Base.:(+))}, Type{Float64}}, sparams=svec(), method=mapreduce_empty(Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000330a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseArrays.LibSuiteSparse.cholmod_l_factorize_p), SparseArrays.CHOLMOD.Sparse{Float64, Int64}, Array{Float64, 1}, Ptr{Nothing}, Int64, SparseArrays.CHOLMOD.Factor{Float64, Int64}, Ref{SparseArrays.LibSuiteSparse.cholmod_common_struct}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e0004060)[Core.MethodMatch(spec_types=Tuple{typeof(SparseArrays.LibSuiteSparse.cholmod_l_factorize_p), SparseArrays.CHOLMOD.Sparse{Float64, Int64}, Array{Float64, 1}, Ptr{Nothing}, Int64, SparseArrays.CHOLMOD.Factor{Float64, Int64}, Ref{SparseArrays.LibSuiteSparse.cholmod_common_struct}}, sparams=svec(), method=cholmod_l_factorize_p(Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000980f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._tuple_error), Type{var"#s181"} where var"#s181"<:Tuple{Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}}, Tuple{Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cacc4fa0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._tuple_error), Type{var"#s181"} where var"#s181"<:Tuple{Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}}, Tuple{Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}}}, sparams=svec(), method=_tuple_error(Type, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000394, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Tuple{String, Real, String, Real, String}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e9892a60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Tuple{String, Real, String, Real, String}, Int64}, sparams=svec(), method=getindex(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{RipQP.Regularization{T}} where T<:Real, RipQP.Regularization{T} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ac85f560)[Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{RipQP.Regularization{T}} where T<:Real, RipQP.Regularization{T} where T<:Real}, sparams=svec(T<:Real, T<:Real), method=convert(Type{RipQP.Regularization{T}}, RipQP.Regularization{T0}) where {T<:Real, T0<:Real}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.check_parent_index_match), AbstractArray{Float64, 1}, Tuple{Array{Int64, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632defdcb80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.check_parent_index_match), AbstractArray{Float64, 1}, Tuple{Array{Int64, 1}}}, sparams=svec(), method=check_parent_index_match(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002e47, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseArrays.CHOLMOD.free!), Ptr{SparseArrays.LibSuiteSparse.cholmod_factor_struct}, Type{Int32}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632aeee9b00)[Core.MethodMatch(spec_types=Tuple{typeof(SparseArrays.CHOLMOD.free!), Ptr{SparseArrays.LibSuiteSparse.cholmod_factor_struct}, Type{Int32}}, sparams=svec(), method=free!(Ptr{SparseArrays.LibSuiteSparse.cholmod_factor_struct}, Type{Int32}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000980f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.dotview), Array{T, 1} 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}(1, 0x7632cd4baca0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.dotview), Array{T, 1} where T<:Real, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(), method=dotview(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a83, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.cconvert), Type{Ptr{Int32}}, Ptr{Nothing}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632d932c6a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.cconvert), Type{Ptr{Int32}}, Ptr{Nothing}}, sparams=svec(), method=cconvert(Type{var"#s66"} where var"#s66"<:(Ptr{T} where T), Any), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000003a4, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._setindex!), Base.IndexCartesian, LinearAlgebra.Diagonal{T, V} where V<:Array{T, 1} where T<:Real, Any, Vararg{Any}}, limit=3), nothing, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), RipQP.Point{Float64, S} where S<:AbstractArray{T, 1} where T<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632eb6aac80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), RipQP.Point{Float64, S} where S<:AbstractArray{T, 1} where T<:Real, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000029f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.rem), Any, Int64}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Array{Float64, N} where N}, Any}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.reshape), LinearAlgebra.Symmetric{Float64, S} where S<:(AbstractArray{var"#s4715", 2} where var"#s4715"<:Float64), Any}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(>)), Float64, Any}, limit=3), nothing, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.axes), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.abs), var"#s185"} where var"#s185"<: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, 0x7632dbb2dba0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.axes), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.abs), var"#s185"} where var"#s185"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real)}}, 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=0x000000000000491a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.axes1), 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}(4, 0x7632eb251760)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.axes1), 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=axes1(Base.SubArray{T, N, P, I, L} where L where I where P where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002ef5, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(-)), Tuple{Array{Base.Rational{Int64}, 1}}}}, typeof(Base.:(-)), Tuple{Array{Base.Rational{Int64}, 1}}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ebe80800)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(-)), Tuple{Array{Base.Rational{Int64}, 1}}}}, typeof(Base.:(-)), Tuple{Array{Base.Rational{Int64}, 1}}, Tuple{Base.OneTo{Int64}}}, sparams=svec(Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(-)), Tuple{Array{Base.Rational{Int64}, 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=0x00000000000048f9, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type, Base.SubArray{Any, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{T, 1} where T<:Real)}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.mightalias), Base.SubArray{_A, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{_A, 1} where _A) where _A, Array{Base.Rational{Int64}, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632d93004a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.mightalias), Base.SubArray{_A, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{_A, 1} where _A) where _A, Array{Base.Rational{Int64}, 1}}, 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=0x0000000000001352, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._broadcast_getindex_evalf), typeof(Base.identity), Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ebb45d20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._broadcast_getindex_evalf), typeof(Base.identity), Any}, sparams=svec(typeof(Base.identity), 1), method=_broadcast_getindex_evalf(Tf, Vararg{Any, N}) where {Tf, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000049e2, 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, 0x7632ad5bfb20)[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=0x000000000000059c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{Nothing, Float64, _A}, 1} where _A, Array{Float64, 1}, Tuple{Vararg{ForwardDiff.Partials{_A, Float64}, _A}} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632ba8e6d60)[ Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{Nothing, Float64, N}, 1}, Array{Float64, 1}, Tuple{Vararg{ForwardDiff.Partials{N, Float64}, N}}} where N, sparams=svec(Nothing, Float64, N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Tuple{Vararg{ForwardDiff.Partials{N, V}, N}}) where {T, V, N}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{Nothing, Float64, _A}, 1} where _A, Array{Float64, 1}, Tuple{Vararg{ForwardDiff.Partials{_A, Float64}, _A}} where _A}, sparams=svec(Nothing, Float64, _A), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any) where {T, V, N}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009830, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), SparseArrays.CHOLMOD.Dense{Tv} where Tv<:Union{Float32, Float64}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b7d72a20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), SparseArrays.CHOLMOD.Dense{Tv} where Tv<:Union{Float32, Float64}, Int64}, sparams=svec(Tv<:Union{Float32, Float64}, 2), method=size(AbstractArray{T, N}, Any) where {T, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000125c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{ft} where ft<:Array{Int64, 1}, Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632da86f820)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Real}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000036c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{Array{Int64, 1}, 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}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632eaa08260)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{Array{Int64, 1}, 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}, Int64, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006ae, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.restart_copyto_nonleaf!), Any, Any, Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Any, Any, Base.IteratorsMD.CartesianIndices{N, R} where R<:Tuple{Vararg{Base.OrdinalRange{Int64, Int64}, N}} where N, Any, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cb774120)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.restart_copyto_nonleaf!), Any, Any, Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Any, Any, Base.IteratorsMD.CartesianIndices{N, R} where R<:Tuple{Vararg{Base.OrdinalRange{Int64, Int64}, N}} where N, Any, 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=0x0000000000004a33, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.real), Base.Complex{T} where T<:Union{Float32, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b73a9d80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.real), Base.Complex{T} where T<:Union{Float32, Float64}}, sparams=svec(), method=real(Base.Complex{T} where T<:Real), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003020, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:x0,), Tuple{Array{Float64, 1}}}, Any, Int64, SolverTest.var"#49#50", Int64, ADNLPModels.var"#3#4"}, limit=3), nothing, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#cvt1#convert##0"{var"#s181", var"#s185"} where var"#s185"<:Tuple{FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}, Array{T, 1} where T<:Number} where var"#s181"<:Tuple{FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}, Array{T, 1} where T<:Number}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ea83bf40)[Core.MethodMatch(spec_types=Tuple{Base.var"#cvt1#convert##0"{var"#s181", var"#s185"} where var"#s185"<:Tuple{FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}, Array{T, 1} where T<:Number} where var"#s181"<:Tuple{FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}, Array{T, 1} where T<:Number}, Int64}, sparams=svec(var"#s181"<:Tuple{FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}, 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=0x0000000000000398, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.iter!), RipQP.Point{T, var"#s185"} where var"#s185"<: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.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.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, 0x7632e112cec0)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.iter!), Union{RipQP.Point{T, var"#s185"} where var"#s185"<: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.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.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=0x0000000000009906, 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, 0x7632ed1885a0)[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=0x00000000000032b5, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.methods), RipQP.var"#PreconditionerData##6#PreconditionerData##7"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632db0881c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.methods), RipQP.var"#PreconditionerData##6#PreconditionerData##7"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real}, sparams=svec(), method=methods(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000005a0, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcast_unalias), Nothing, Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e10a46a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcast_unalias), Nothing, Real}, sparams=svec(), method=broadcast_unalias(Nothing, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a0c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), AbstractArray{Float64, 1}, Float64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bb6b0060)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), AbstractArray{Float64, 1}, Float64}, sparams=svec(), method=combine_styles(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004974, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.show_type_name), Base.IOContext{Base.GenericIOBuffer{Memory{UInt8}}}, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b8d3c040)[Core.MethodMatch(spec_types=Tuple{typeof(Base.show_type_name), Base.IOContext{Base.GenericIOBuffer{Memory{UInt8}}}, Core.TypeName}, sparams=svec(), method=show_type_name(IO, Core.TypeName), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000042be, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unsafe_convert), Type{Ptr{SparseArrays.LibSuiteSparse.cholmod_factor_struct}}, SparseArrays.CHOLMOD.Factor{Tnew, Int64} where Tnew<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ae61f380)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_convert), Type{Ptr{SparseArrays.LibSuiteSparse.cholmod_factor_struct}}, SparseArrays.CHOLMOD.Factor{Tnew, Int64} where Tnew<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}}, sparams=svec(SparseArrays.LibSuiteSparse.cholmod_factor_struct), method=unsafe_convert(Type{Ptr{T}}, Union{SparseArrays.CHOLMOD.Dense{Tv} where Tv<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}, SparseArrays.CHOLMOD.Factor{Tv, Ti} where Ti<:Union{Int32, Int64} where Tv<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}, SparseArrays.CHOLMOD.Sparse{Tv, Ti} where Ti<:Union{Int32, Int64} where Tv<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}}) where {T<:Union{SparseArrays.LibSuiteSparse.cholmod_dense_struct, SparseArrays.LibSuiteSparse.cholmod_factor_struct, SparseArrays.LibSuiteSparse.cholmod_sparse_struct}}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000980f, 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, Nothing}, 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, 0x7632db957700)[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, Nothing}, 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}, Nothing), 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=0x0000000000009856, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{Integer, Integer}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ad0f9d60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{Integer, Integer}, Int64, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006ae, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ReverseDiff.hastape), LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4715", 2} where var"#s4715"<:T) where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632af3ddaa0)[ Core.MethodMatch(spec_types=Tuple{typeof(ReverseDiff.hastape), LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4715", 2} where var"#s4715"<:T) where T}, sparams=svec(), method=hastape(AbstractArray{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009844, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{SparseArrays.CHOLMOD.CHOLMODException}, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ec36c780)[Core.MethodMatch(spec_types=Tuple{Type{SparseArrays.CHOLMOD.CHOLMODException}, String}, sparams=svec(), method=(::Type{SparseArrays.CHOLMOD.CHOLMODException})(String), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000980f, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Tuple, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ec72fac0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Tuple, Int64}, sparams=svec(), method=getindex(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.print_to_string), String, Type}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dc237440)[Core.MethodMatch(spec_types=Tuple{typeof(Base.print_to_string), String, Type}, sparams=svec(), method=print_to_string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003ea0, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.ismutable), NLPModels.NLPModelMeta{T, S} where S where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bb196920)[Core.MethodMatch(spec_types=Tuple{typeof(Base.ismutable), NLPModels.NLPModelMeta{T, S} where S where T<:Real}, sparams=svec(), method=ismutable(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000519, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.newindexer), Array{_A, 2} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632d9e67520)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.newindexer), Array{_A, 2} where _A}, sparams=svec(), method=newindexer(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000049ba, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_type), Type, typeof(DataType)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7632e19c0ce0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_type), Type{Union{}}, typeof(DataType)}, sparams=svec(T), method=promote_type(Type{Union{}}, Type{T}) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_type), Type{T}, typeof(DataType)} where T, sparams=svec(T), method=promote_type(Type{T}, Type{T}) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_type), Type, typeof(DataType)}, sparams=svec(T, T), method=promote_type(Type{T}, Type{S}) where {T, S}, fully_covers=true), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000621, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), Any, typeof(Base.:(<=)), AbstractArray{var"#s682", 1} where var"#s682", AbstractArray{var"#s682", 1} where var"#s682"}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(6, 0x7632cb10e280)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Base.Broadcast.DefaultArrayStyle{N} where N, typeof(Base.:(<=)), FillArrays.AbstractFill{var"#s682", 1, Axes} where Axes where var"#s682", FillArrays.AbstractFill{var"#s682", 1, Axes} where Axes where var"#s682"}, 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{var"#s682", 1} where var"#s682", AbstractArray{var"#s682", 1} where var"#s682"}, 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{var"#s682", 1} where var"#s682", AbstractArray{var"#s682", 1} where var"#s682"}, sparams=svec(F), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000981b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.argtail), 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, 0x7632b64e4820)[Core.MethodMatch(spec_types=Tuple{typeof(Base.argtail), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Ti, 1} where Ti<:Integer), Int64}, sparams=svec(), method=argtail(Any, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000037b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.extrude), Array{T, 1} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dbc117e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.extrude), Array{T, 1} where T<:Real}, sparams=svec(), method=extrude(AbstractArray{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000049d8, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(MatrixMarket.generate_eltype), Type{T} where T<:Real}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), var"#s185"} where var"#s185"<: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"{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, 0x7632afad9320)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), var"#s185"} where var"#s185"<: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"{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=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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.finalizer), typeof(SparseArrays.CHOLMOD.free!), 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, 0x7632b8c40a80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.finalizer), typeof(SparseArrays.CHOLMOD.free!), SparseArrays.CHOLMOD.Sparse{Tv, Int32} where Tv<:Union{Float32, Float64}}, sparams=svec(), method=finalizer(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000041f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{Bool, Tuple{Any, Any}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632afb11920)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{Bool, Tuple{Any, Any}}, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006ad, 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, 0x7632cb0bd100)[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{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(SparseMatricesCOO.replace_if_minusinf), Tuple{Array{R, 1} where R<:Real, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b7221680)[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(SparseMatricesCOO.replace_if_minusinf), Tuple{Array{R, 1} where R<:Real, 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) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048f3, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Iterators._zip_iterate_some), Tuple{Any, Any}, Tuple{Tuple{Any}, Tuple{Any}}, Tuple{Any, Any}, Base.Missing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632ace9b720)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators._zip_iterate_some), Tuple{Any, Any}, Tuple{Tuple{Any}, Tuple{Any}}, Tuple{Base.Missing, Any}, Base.Missing}, sparams=svec(Base.Missing), 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, Any}, Tuple{Tuple{Any}, Tuple{Any}}, Tuple{Any, Any}, Base.Missing}, sparams=svec(), method=_zip_iterate_some(Any, Any, Tuple{Any, Vararg{Any}}, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001909, 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##12#PreconditionerData##13"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real) where _A, 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, 0x7632b58bb7e0)[Core.MethodMatch(spec_types=Tuple{Type{LinearOperators.LinearOperator{_A, Int64, F, Nothing, Nothing, T}} where T where F<:(RipQP.var"#PreconditionerData##12#PreconditionerData##13"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real) where _A, 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=0x0000000000009848, 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}, Array{_A, 1} where _A, Tuple{Base.UnitRange{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e148d840)[Core.MethodMatch(spec_types=Tuple{Type{Base.SubArray{T, N, P, I, L} where L where I where P where N where T}, Array{_A, 1} where _A, Tuple{Base.UnitRange{Int64}}}, sparams=svec(), method=(::Type{Base.SubArray{T, N, P, I, L} where L where I where P where N where T})(AbstractArray{T, N} where N where T, Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002e43, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), Real, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ca136da0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), Real, Any}, sparams=svec(), method=combine_styles(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004974, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{Union{Pair{Symbol, Array{QuadraticModels.PresolveOperation{Float64, Array{Float64, 1}}, 1}}, Pair{Symbol, QuadraticModels.PresolvedQuadraticModel{Float64, Array{Float64, 1}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}}}}, Int64}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632df733ee0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{Union{Pair{Symbol, Array{QuadraticModels.PresolveOperation{Float64, Array{Float64, 1}}, 1}}, Pair{Symbol, QuadraticModels.PresolvedQuadraticModel{Float64, Array{Float64, 1}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}}}}, Int64}, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006ad, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Iterators._zip_iterate_all), Tuple{AbstractArray{T, 1} where T, AbstractArray{T, 1} where T}, Tuple{Tuple{}, Tuple{}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ead35440)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators._zip_iterate_all), Tuple{AbstractArray{T, 1} where T, AbstractArray{T, 1} where T}, Tuple{Tuple{}, Tuple{}}}, sparams=svec(), method=_zip_iterate_all(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001906, 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, 0x7632b7c6a7e0)[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=0x0000000000009906, 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, 0x7632ec36cde0)[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=0x0000000000000527, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Any, QuadraticModels.Col{T} where T}, limit=3), nothing, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{LinearOperators.var"##LinearOperator#14", Type{Array{_A, 1}} where _A, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, typeof(DataType), Int64, Int64, Bool, Bool, QuadraticModels.var"#opPermutedMinusOnes##0#opPermutedMinusOnes##1"{Array{Int64, 1}}, QuadraticModels.var"#opPermutedMinusOnes##2#opPermutedMinusOnes##3"{Array{Int64, 1}}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bbbdcb00)[Core.MethodMatch(spec_types=Tuple{LinearOperators.var"##LinearOperator#14", Type{Array{_A, 1}} where _A, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, typeof(DataType), Int64, Int64, Bool, Bool, QuadraticModels.var"#opPermutedMinusOnes##0#opPermutedMinusOnes##1"{Array{Int64, 1}}, QuadraticModels.var"#opPermutedMinusOnes##2#opPermutedMinusOnes##3"{Array{Int64, 1}}, Nothing}, sparams=svec(T, 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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unalias), Array{Int64, 1}, Base.LogicalIndex{Int64, Base.BitArray{N}} where N}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632da08c860)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.unalias), Array{Int64, 1}, 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=0x0000000000001347, 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.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##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, 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, 0x7632dbd81ac0)[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.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##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, 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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Iterators._zip_isdone), Tuple{Array{T, 1} where T<:Real}, Tuple{Tuple{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ad009520)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators._zip_isdone), Tuple{Array{T, 1} where T<:Real}, Tuple{Tuple{Int64}}}, sparams=svec(), method=_zip_isdone(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001910, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"##unsafe_wrap#64", 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, 0x7632ea2e5ca0)[Core.MethodMatch(spec_types=Tuple{Base.var"##unsafe_wrap#64", Bool, typeof(Base.unsafe_wrap), Type{Array{T, N} where N where T}, Ptr{Float64}, Tuple{UInt64}}, sparams=svec(Float64, 1), method=var"#unsafe_wrap#64"(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"#s183", Core.AddrSpace{Core}(0x00)} where var"#s183"}, Type{GenericMemory{kind, T, Core.AddrSpace{Core}(0x00)}}} where kind, Ptr{T}, Tuple{Vararg{var"#s182", N}} where var"#s182"<:Integer) where {T, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000cc5, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._tuple_error), Type{var"#s181"} where var"#s181"<: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)}, 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)}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632da830aa0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._tuple_error), Type{var"#s181"} where var"#s181"<: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)}, 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)}}, sparams=svec(), method=_tuple_error(Type, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000394, 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, 0x7632acd8b460)[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=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eltype), SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv<:Real}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e0756000)[Core.MethodMatch(spec_types=Tuple{typeof(Base.eltype), SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv<:Real}, sparams=svec(), method=eltype(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000127a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#promote_eltype##0#promote_eltype##1", Any, Array{Int64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cb075e80)[Core.MethodMatch(spec_types=Tuple{Base.var"#promote_eltype##0#promote_eltype##1", Type{T}, Array{Int64, 1}} where T, sparams=svec(T), method=var"#promote_eltype##0"(Type{T}, Any) where {T}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001387, 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}, AbstractArray{Float64, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632e0fd9ce0)[ 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}, AbstractArray{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}, AbstractArray{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=0x00000000000048f3, 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, 0x7632b8796420)[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=0x0000000000002ecb, 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, Nothing, Tuple{Base.RefValue{typeof(RipQP.safe_boundary)}, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dad4ac40)[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, Nothing, Tuple{Base.RefValue{typeof(RipQP.safe_boundary)}, Any}}, sparams=svec(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) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048f3, 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.SingletonRow{T, S} where T<:Real where S, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632b63043a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.__safe_setindex!), Array{QuadraticModels.PresolveOperation{T, S}, 1}, QuadraticModels.SingletonRow{T, S}, Int64} where S where T<:Real, sparams=svec(T<:(Union{QuadraticModels.PresolveOperation{T, S}, QuadraticModels.SingletonRow{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.SingletonRow{T, S} where T<:Real where S, 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=0x0000000000001150, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, 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, 0x7632e0debda0)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, 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=(::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{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##14#PreconditionerData##15"{var"#s185"} where var"#s185"<:RipQP.FactorizationData{Tlow} where Tlow<:Real, Nothing, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b5eab900)[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##14#PreconditionerData##15"{var"#s185"} where var"#s185"<: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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.DimensionMismatch}, Base.LazyString}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ed179f60)[Core.MethodMatch(spec_types=Tuple{Type{Base.DimensionMismatch}, Base.LazyString}, sparams=svec(), method=(::Type{Base.DimensionMismatch})(AbstractString), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010a6, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._simple_count), typeof(Base.identity), 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), Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ea605cc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._simple_count), typeof(Base.identity), 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), Int64}, sparams=svec(), method=_simple_count(Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000033a3, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eltype), Type{FillArrays.Zeros{Float64, 1, Tuple{Base.OneTo{Int64}}}}}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632b85f3e20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.eltype), Type{FillArrays.Zeros{Float64, 1, Tuple{Base.OneTo{Int64}}}}}, sparams=svec(Float64), method=eltype(Type{var"#s185"} where var"#s185"<:(AbstractArray{E, N} where N)) where {E}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000127b, 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{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632eb7f7c40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R}, 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=0x000000000000491c, 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, 0x7632ea23de20)[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=0x0000000000009860, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LinearAlgebra.mul!), Any, Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where T<:Real, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.dotgetproperty), RipQP.AbstractResiduals{T, S} where S where T<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bb03f080)[Core.MethodMatch(spec_types=Tuple{typeof(Base.dotgetproperty), RipQP.AbstractResiduals{T, S} where S where T<:Real, Symbol}, sparams=svec(), method=dotgetproperty(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000002a2, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Memory{Float64}}, UndefInitializer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dedcd820)[Core.MethodMatch(spec_types=Tuple{Type{Memory{Float64}}, UndefInitializer, Int64}, sparams=svec(Float64, Core.AddrSpace{Core}(0x00), :not_atomic), method=(::Type{GenericMemory{kind, T, addrspace}})(UndefInitializer, Int64) where {T, addrspace, kind}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000100, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{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}, Float64}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cda9a7c0)[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}, Float64}, 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=0x00000000000048f4, 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<:(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, 0x7632bb094de0)[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<:(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(T<:Real, S, M1<:(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv), M2<:(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv)), 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=0x00000000000098de, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.init_fact), Any, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7632df6ec1e0)[ Core.MethodMatch(spec_types=Tuple{typeof(RipQP.init_fact), LinearAlgebra.Symmetric{T, SparseArrays.SparseMatrixCSC{T, Int64}}, RipQP.LDLFact} where T, sparams=svec(T), method=init_fact(LinearAlgebra.Symmetric{T, SparseArrays.SparseMatrixCSC{T, Int64}}, RipQP.LDLFact) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(RipQP.init_fact), LinearAlgebra.Symmetric{T, SparseArrays.SparseMatrixCSC{T, Int64}}, RipQP.LLDLFact} where T, sparams=svec(T), method=init_fact(LinearAlgebra.Symmetric{T, SparseArrays.SparseMatrixCSC{T, Int64}}, RipQP.LLDLFact) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(RipQP.init_fact), LinearAlgebra.Symmetric{T, SparseArrays.SparseMatrixCSC{T, Int64}}, RipQP.CholmodFact} where T, sparams=svec(T), method=init_fact(LinearAlgebra.Symmetric{T, SparseArrays.SparseMatrixCSC{T, Int64}}, RipQP.CholmodFact) where {T}, fully_covers=false), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.sort!), Array{T, 1} where T<:Integer, Any, Integer, Base.Sort.MergeSortAlg, Base.Order.ForwardOrdering, Any}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.oneunit), Type{T} where T<:Union{Float32, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(6, 0x7632b7136190)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.oneunit), Type{Union{}}}, sparams=svec(), method=oneunit(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.oneunit), Type{T} where T<:Union{Float32, Float64}}, sparams=svec(T<:Union{Float32, Float64}), method=oneunit(Type{T}) where {T}, fully_covers=true), #, #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000ab2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._str_sizehint), Array{R, 1} where R<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b884ce40)[Core.MethodMatch(spec_types=Tuple{typeof(Base._str_sizehint), Array{R, 1} where R<:Real}, sparams=svec(), method=_str_sizehint(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003e9e, 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, 0x7632ed1aa6c0)[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=0x0000000000009849, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.push!), Array{QuadraticModels.PresolveOperation{T, S}, 1} where S where T<:Real, QuadraticModels.RemoveIfix{T, _A} where _A where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632ac920ae0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.push!), Array{QuadraticModels.PresolveOperation{T, S}, 1} where S where T<:Real, QuadraticModels.RemoveIfix{T, _A} where _A where T<:Real}, sparams=svec(T<:(QuadraticModels.PresolveOperation{T, S} where T<:Real where S)), method=push!(Array{T, 1}, Any) where {T}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000116a, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{UInt32}, Int32}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632eae63e40)[Core.MethodMatch(spec_types=Tuple{Type{UInt32}, Int32}, sparams=svec(), method=(::Type{UInt32})(Union{Bool, Int128, Int16, Int32, Int64, Int8, UInt128, UInt16, UInt32, UInt64, UInt8}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000232, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.axes), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s185"} where var"#s185"<: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, 0x7632e0c37b20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.axes), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s185"} where var"#s185"<: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=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=0x000000000000491a, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.preprocess), Array{_A, 1} where _A, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.imag), var"#s185"} where var"#s185"<: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, 0x7632ae0f1fa0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.preprocess), Array{_A, 1} where _A, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.imag), var"#s185"} where var"#s185"<: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=0x0000000000004a0e, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseArrays.LibSuiteSparse.cholmod_l_allocate_sparse), Int64, Int64, Int64, Bool, Bool, Int64, Int64, Ref{SparseArrays.LibSuiteSparse.cholmod_common_struct}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ec7144c0)[Core.MethodMatch(spec_types=Tuple{typeof(SparseArrays.LibSuiteSparse.cholmod_l_allocate_sparse), Int64, Int64, Int64, Bool, Bool, Int64, Int64, Ref{SparseArrays.LibSuiteSparse.cholmod_common_struct}}, sparams=svec(), method=cholmod_l_allocate_sparse(Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000980f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eachindex), Base.IndexCartesian, Base.Broadcast.Broadcasted{Nothing, var"#s185", typeof(Base.:(/)), var"#s185"} where var"#s185"<: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)} where var"#s185"<:Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632da9c9900)[Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), Base.IndexCartesian, Base.Broadcast.Broadcasted{Nothing, var"#s185", typeof(Base.:(/)), var"#s185"} where var"#s185"<: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)} where var"#s185"<:Tuple}, 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=0x0000000000004926, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.cat_size), Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7632bb73eae0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.cat_size), LinearAlgebra.AbstractQ{T} where T}, sparams=svec(), method=cat_size(LinearAlgebra.AbstractQ{T} where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.cat_size), AbstractArray{T, N} where N where T}, sparams=svec(), method=cat_size(AbstractArray{T, N} where N where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.cat_size), Any}, sparams=svec(), method=cat_size(Any), fully_covers=true), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009178, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), Base.SubArray{Float64, 1, Array{Float64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.identity), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632ea40ff20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.SubArray{Float64, 1, Array{Float64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.identity), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R}}, sparams=svec(), method=materialize!(Any, Base.Broadcast.Broadcasted{var"#s683", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s683"), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a02, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{SparseArrays.CHOLMOD.var"##symbolic#10", 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, 0x7632dec77060)[Core.MethodMatch(spec_types=Tuple{SparseArrays.CHOLMOD.var"##symbolic#10", 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#10"(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=0x000000000000980f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copy), LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4715", 2} where var"#s4715"<:T) where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ac9a0d80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.copy), LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4715", 2} where var"#s4715"<:T) where T}, sparams=svec(), method=copy(LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4715", 2} where var"#s4715"<:T) where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000893a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eltype), LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T<:Real}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ad4dd640)[Core.MethodMatch(spec_types=Tuple{typeof(Base.eltype), LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T<:Real}, sparams=svec(T<:Real), method=eltype(LinearOperators.AbstractLinearOperator{T}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009848, 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, 0x7632b9c037a0)[ 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=0x00000000000098c6, 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, 0x7632da7fb4e0)[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=0x000000000000029f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(var"==")), AbstractArray{T, 1} where T, AbstractArray{T, 1} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632de5294e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(var"==")), AbstractArray{T, 1} where T, AbstractArray{T, 1} where T}, sparams=svec(typeof(Base.:(var"=="))), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a9d, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Real}}, UInt64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b83488c0)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{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{ForwardDiff.JacobianConfig{T, V, N, D} where D where N where V where T}, Any, Array{Float64, 1}, ForwardDiff.Chunk{N} where N}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cbf01420)[Core.MethodMatch(spec_types=Tuple{Type{ForwardDiff.JacobianConfig{T, V, N, D} where D where N where V where T}, Any, Array{Float64, 1}, ForwardDiff.Chunk{N} where N}, sparams=svec(F, Float64, N), method=(::Type{ForwardDiff.JacobianConfig{T, V, N, D} where D where N where V where T})(F, AbstractArray{V, N} where N, ForwardDiff.Chunk{N}) where {F, V, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009830, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s185"} where var"#s185"<: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=(2,), mem=Memory{Any}(6, 0x7632d93296f0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), Union{}}, Int64}, sparams=svec(T, S), method=_broadcast_getindex(Base.Broadcast.Broadcasted{var"#s683", var"#s682", var"#s681", var"#s680"} where var"#s680"<:Tuple{Ref{Type{T}}, Ref{Type{S}}, Vararg{Any}} where var"#s681" where var"#s682" where var"#s683", Any) where {T, S}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s185"} where var"#s185"<: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=_broadcast_getindex(Base.Broadcast.Broadcasted{var"#s683", var"#s682", var"#s681", var"#s680"} where var"#s680" where var"#s681" where var"#s682" where var"#s683", Any), fully_covers=true), #, #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000049dd, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.typeintersect), Type{Tuple{Any}}, Type{var"#s181"} where var"#s181"<:Tuple{Base.Broadcast.Broadcasted{var"#s185", Nothing, typeof(Base.sqrt), var"#s185"} where var"#s185"<:Tuple{AbstractArray{Float64, 1}} where var"#s185"<:Base.Broadcast.BroadcastStyle}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632d9a24600)[Core.MethodMatch(spec_types=Tuple{typeof(Base.typeintersect), Type{Tuple{Any}}, Type{var"#s181"} where var"#s181"<:Tuple{Base.Broadcast.Broadcasted{var"#s185", Nothing, typeof(Base.sqrt), var"#s185"} where var"#s185"<:Tuple{AbstractArray{Float64, 1}} where var"#s185"<:Base.Broadcast.BroadcastStyle}}, sparams=svec(), method=typeintersect(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000547, 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{T, N} where N where T, AbstractArray{T, N} where N where T}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632db2f19a0)[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{T, N} where N where T, AbstractArray{T, N} where N where T}, 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=0x00000000000048f4, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.default_access_order), Memory{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, 0x7632b9cebf40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.default_access_order), Memory{T} where T<:(QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2} where T where S where M1 where M2)}, sparams=svec(), method=default_access_order(GenericMemory{:not_atomic, T, addrspace} where addrspace where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000362, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Type{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, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ed0b7da0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Type{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, Symbol}, sparams=svec(), method=getproperty(Type, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000299, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Iterators.zip), Base.OneTo{Int64}, Any, Base.OneTo{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ea557c80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators.zip), Base.OneTo{Int64}, Any, Base.OneTo{Int64}}, sparams=svec(), method=zip(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000018e7, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.eltypes), Tuple{Array{Ti, 1} where Ti<:Integer, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b69ff7a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.eltypes), Tuple{Array{Ti, 1} where Ti<:Integer, Int64}}, sparams=svec(), method=eltypes(Tuple{Any, Any}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000049ef, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.Generator{I, typeof(Base.identity)} where I<:(Base.LogicalIndex{T, A} where A<:(AbstractArray{Bool, N} where N) where T), Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ebd4f8a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.Generator{I, typeof(Base.identity)} where I<:(Base.LogicalIndex{T, A} where A<:(AbstractArray{Bool, N} where N) where T), Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000029f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Base.Generator{Base.UnitRange{Int64}, F} where F<:(Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##0#__cat_offset1!##1"{Tuple{Int64}, 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, 0x7632cac7ec80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Base.Generator{Base.UnitRange{Int64}, F} where F<:(Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##0#__cat_offset1!##1"{Tuple{Int64}, Tuple{Bool}, Tuple{Int64}, Array{Ti, 1}}} where Ti<:Integer)}, sparams=svec(), method=iterate(Base.Generator{I, F} where F where I, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000044b, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._fill!), Array{T, 1} where T<:Real, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ba357f20)[Core.MethodMatch(spec_types=Tuple{typeof(Base._fill!), Array{T, 1}, Real} where T<:Real, sparams=svec(T), method=_fill!(Array{T, N} where N, T) where {T}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010e3, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._setindex!), Array{T, 1} where T<:Real, Real, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dc9564a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._setindex!), Array{T, 1}, Real, Int64} where T<:Real, sparams=svec(T), method=_setindex!(Array{T, N} where N, T, Int64) where {T}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000114a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), 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, 0x7632b80e1ec0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), Array{R, 1} where R<:Real, Array{R, 1} where R<:Real}, sparams=svec(), method=combine_styles(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004974, 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}, RipQP.K2LDLParams{T, RipQP.LDLFact} where T<:Real, RipQP.PC}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632acda5560)[Core.MethodMatch(spec_types=Tuple{Type{RipQP.RipQPMonoParameters{T, SP1, SM1} where SM1<:RipQP.SolveMethod where SP1<:RipQP.SolverParams{T} where T<:Real}, RipQP.K2LDLParams{T, RipQP.LDLFact} where T<:Real, RipQP.PC}, sparams=svec(T<:Real, SP1<:(RipQP.K2LDLParams{T, RipQP.LDLFact} where T<:Real), RipQP.PC), method=(::Type{RipQP.RipQPMonoParameters{T, SP1, SM1} where SM1 where SP1 where T})(SP1, SM1) where {T<:Real, SP1<:RipQP.SolverParams{T}, SM1<:RipQP.SolveMethod}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, 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, 0x7632ac74c060)[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=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.any), Base.var"#TupleOrBottom##0#TupleOrBottom##1", Tuple{Any, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e96f13c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.any), Base.var"#TupleOrBottom##0#TupleOrBottom##1", Tuple{Any, Any}}, sparams=svec(), method=any(Any, Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001b21, 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.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}, Nothing, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ea496ac0)[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.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}, 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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), Array{Float64, 1}, Float64, Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632ea63ef20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Array{Float64, 1}, Float64, Int64}, sparams=svec(Float64), method=setindex!(Array{T, N} where N, Any, Int64) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Array{Float64, 1}, Float64, 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=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{Nothing, Float64, _A}, 1} where _A, Array{Float64, 1}, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7632df7453e0)[ Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{Nothing, Float64, N}, 1}, Array{Float64, 1}, ForwardDiff.Partials{N, Float64}} where N, sparams=svec(Nothing, Float64, N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, ForwardDiff.Partials{N, V}) where {T, V, N}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{Nothing, Float64, N}, 1}, Array{Float64, 1}, Tuple{Vararg{ForwardDiff.Partials{N, Float64}, N}}} where N, sparams=svec(Nothing, Float64, N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Tuple{Vararg{ForwardDiff.Partials{N, V}, N}}) where {T, V, N}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{Nothing, Float64, _A}, 1} where _A, Array{Float64, 1}, Any}, sparams=svec(Nothing, Float64, _A), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any) where {T, V, N}, fully_covers=true), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009830, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), QuadraticModels.QPData{Float64, S, M1, M2} where M2<:(AbstractArray{T, 2} where T) where M1<:(AbstractArray{T, 2} where T) where S, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632eabfc280)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), QuadraticModels.QPData{Float64, S, M1, M2} where M2<:(AbstractArray{T, 2} where T) where M1<:(AbstractArray{T, 2} where T) where S, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000029f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Array{Tv, 1} where Tv<:Float64, Any}, limit=3), nothing, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Tuple{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}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bb550fa0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Tuple{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}, Int64}, sparams=svec(), method=getindex(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseMatricesCOO.maximum_sym_vec!), typeof(Base.abs), Array{T, 1} where T<:Real, SparseMatricesCOO.SparseMatrixCOO{T, Ti} where Ti<:Integer where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b7274760)[Core.MethodMatch(spec_types=Tuple{typeof(SparseMatricesCOO.maximum_sym_vec!), typeof(Base.abs), Array{T, 1}, SparseMatricesCOO.SparseMatrixCOO{T, Ti} where Ti<:Integer} where T<:Real, sparams=svec(T<:Real), method=maximum_sym_vec!(Function, AbstractArray{T, 1}, SparseMatricesCOO.SparseMatrixCOO{T, Ti} where Ti<:Integer) where {T}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000098dd, 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, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}}}, UInt64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cb378b80)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Any, Base.RefValue{T} where T, Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{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{Type{LinearAlgebra.UpperTriangular{T, S} where S<:AbstractArray{T, 2} where T}, AbstractArray{var"#s4715", 2} where var"#s4715"}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632accae320)[ Core.MethodMatch(spec_types=Tuple{Type{LinearAlgebra.UpperTriangular{T, S} where S<:AbstractArray{T, 2} where T}, LinearAlgebra.UpperTriangular{T, S} where S<:AbstractArray{T, 2} where T}, sparams=svec(), method=(::Type{LinearAlgebra.UpperTriangular{T, S} where S<:AbstractArray{T, 2} where T})(LinearAlgebra.UpperTriangular{T, S} where S<:AbstractArray{T, 2} where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{LinearAlgebra.UpperTriangular{T, S} where S<:AbstractArray{T, 2} where T}, AbstractArray{var"#s4715", 2} where var"#s4715"}, sparams=svec(), method=(::Type{LinearAlgebra.UpperTriangular{T, S} where S<:AbstractArray{T, 2} where T})(AbstractArray{T, 2} where T), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000008564, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.maxintfloat), Type{Float64}, Type{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632baa16e60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.maxintfloat), Type{Float64}, Type{Int64}}, sparams=svec(Float64, Int64), method=maxintfloat(Type{S}, Type{T}) where {S<:AbstractFloat, T<:Integer}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000005716, 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"#s185"} where var"#s185"<: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, 0x7632e1897120)[Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s185"} where var"#s185"<: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=0x00000000000049ca, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.convert_types), Type{Float64}, 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{Float64, RipQP.LDLFact}, RipQP.SolverParams{Float64}, RipQP.QM_IntData, 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.PC, RipQP.PC}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632d9cde940)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.convert_types), Type{Float64}, 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{Float64, RipQP.LDLFact}, RipQP.SolverParams{Float64}, RipQP.QM_IntData, 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.PC, RipQP.PC} where S_old where T_old<:Real, sparams=svec(Float64, 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=0x0000000000009906, 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{AbstractArray{T, 1} where T<:Real, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632db3de380)[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{AbstractArray{T, 1} where T<:Real, Float64}}, 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=0x00000000000048f3, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s181"} where var"#s181"<:Base.RefValue{typeof(Base.:(/))}, Base.RefValue{typeof(Base.:(/))}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632cb978a60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Base.RefValue{typeof(Base.:(/))}}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Base.RefValue{typeof(Base.:(/))}}, Base.RefValue{typeof(Base.:(/))}}, sparams=svec(Base.RefValue{typeof(Base.:(/))}), method=convert(Type{T}, T) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000036c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Array{Tv, 1}} where Tv<:Real, Array{T, 1} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e03772e0)[Core.MethodMatch(spec_types=Tuple{Type{Array{Tv, 1}} where Tv<:Real, Array{T, 1} where T<:Real}, sparams=svec(Tv<:Real, 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=0x0000000000001113, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eltype), AbstractArray{T, 1} where T<:Real}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632ad2dbb20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.eltype), SparseArrays.ReadOnly{T, 1, V} where V<:AbstractArray{T, 1} where T<:Real}, 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{T, 1} where T<:Real}, sparams=svec(), method=eltype(Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000980f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.change_vector_eltype), Type{var"#s185"} where var"#s185"<:AbstractArray{T, 1} where T<:Real, Type{T} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ad9815e0)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.change_vector_eltype), Type{var"#s44"} where var"#s44"<:Array{T, 1} where T<:Real, Type{T}} where T<:Real, sparams=svec(T<:Real), method=change_vector_eltype(Type{var"#s44"} where var"#s44"<:(Array{T, 1} where T), Type{T}) where {T}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.compute_αs), AbstractArray{Float64, 1}, AbstractArray{Float64, 1}, AbstractArray{Float64, 1}, Any, Any, Any, Any, Any, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b8715be0)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.compute_αs), AbstractArray{Float64, 1}, AbstractArray{Float64, 1}, AbstractArray{Float64, 1}, Any, Any, Any, Any, Any, Int64}, sparams=svec(), method=compute_αs(Any, Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{LinearAlgebra.Adjoint{T, var"#s185"} where var"#s185"<:AbstractArray{T, 1} where Float64<:T<:Real, Float64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dbe19240)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{LinearAlgebra.Adjoint{T, var"#s185"} where var"#s185"<:AbstractArray{T, 1} where Float64<:T<:Real, 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.setindex!), AbstractArray{T, 1} where Float64<:T<:Real, Any, Integer}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.mightalias), Array{_A, 1} where _A, Array{Ti, 1} where Ti<:Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632eaa485a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.mightalias), Array{_A, 1} where _A, Array{Ti, 1} where Ti<:Integer}, 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=0x0000000000001352, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core._typeof_captured_variable), LinearAlgebra.Hermitian{T, S} where S<:(AbstractArray{var"#s4715", 2} where var"#s4715"<:T) where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ca937dc0)[Core.MethodMatch(spec_types=Tuple{typeof(Core._typeof_captured_variable), LinearAlgebra.Hermitian{T, S} where S<:(AbstractArray{var"#s4715", 2} where var"#s4715"<:T) 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.deepcopy_internal), NLPModels.NLPModelMeta{T, S} where S where T<:Real, Base.IdDict{Any, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bb1c6f40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.deepcopy_internal), NLPModels.NLPModelMeta{T, S} where S where T<:Real, 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=0x0000000000006632, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.axes), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.iszero)}, var"#s185"} where var"#s185"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool, Bool}, Tuple{Int64, Int64}} where T<:(Array{_A, 2} where _A)}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cbc25c60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.axes), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.iszero)}, var"#s185"} where var"#s185"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool, Bool}, Tuple{Int64, Int64}} where T<:(Array{_A, 2} where _A)}}, 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=0x000000000000491a, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e0824da0)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}}}, 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.Broadcast.broadcasted), typeof(Base.:(-)), AbstractArray{T, 1} where T<:Real, AbstractArray{T, 1} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632e9a0ad60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(-)), AbstractArray{T, 1} where T<:Real, AbstractArray{T, 1} where T<:Real}, sparams=svec(typeof(Base.:(-))), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a9d, 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}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dcfa40c0)[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}, 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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core._typeof_captured_variable), Tuple{Base.RefValue{typeof(Base.:(>))}, AbstractArray{T, N} where N where T, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ecd1a6c0)[Core.MethodMatch(spec_types=Tuple{typeof(Core._typeof_captured_variable), Tuple{Base.RefValue{typeof(Base.:(>))}, AbstractArray{T, N} where N where T, 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.string), String, Type{T} where T<:Real, String, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632eb254a00)[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=0x0000000000003ea3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.CanonicalIndexError}, String, Type{Base.SubArray{T, 2, 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, 0x7632eb2a1560)[Core.MethodMatch(spec_types=Tuple{Type{Base.CanonicalIndexError}, String, Type{Base.SubArray{T, 2, P, I, L}} where L where I where P where T}, sparams=svec(), method=(::Type{Base.CanonicalIndexError})(String, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001316, 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, 0x7632b97b3ea0)[ 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=0x0000000000001312, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"##_#58", Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, 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.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, 0x7632eabd3800)[Core.MethodMatch(spec_types=Tuple{Base.var"##_#58", Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, 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.MappingRF{Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}, Base.BottomRF{typeof(Base.add_sum)}}}, sparams=svec(), method=var"#_#58"(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=0x0000000000000c7a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.axes), FillArrays.AbstractZeros{T, 1, Axes} where Axes where Float64<:T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632de0f2220)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.axes), FillArrays.Zeros{T, 1, Axes} where Axes where Float64<:T<:Real}, sparams=svec(), method=axes(FillArrays.Zeros{T, N, Axes} where Axes where N where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.axes), FillArrays.AbstractZeros{T, 1, Axes} where Axes where Float64<:T<:Real}, sparams=svec(), method=axes(Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000981b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.TwicePrecision{T} where T}, Float32}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ba7748c0)[Core.MethodMatch(spec_types=Tuple{Type{Base.TwicePrecision{T} where T}, Float32}, sparams=svec(), method=(::Type{Base.TwicePrecision{T} where T})(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002f9b, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.argtail), Base.OneTo{Int64}, Any, Base.OneTo{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ea47a460)[Core.MethodMatch(spec_types=Tuple{typeof(Base.argtail), Base.OneTo{Int64}, Any, Base.OneTo{Int64}}, sparams=svec(), method=argtail(Any, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000037b, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LinearAlgebra.ldiv!), LinearAlgebra.Diagonal{Float64, Array{Float64, 1}}, AbstractArray{var"#s4715", 2} where var"#s4715"<:Float64}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{RipQP.IterData{T, S} where S where T<:Real}, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Bool, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ca6525c0)[Core.MethodMatch(spec_types=Tuple{Type{RipQP.IterData{T, S} where S where T<:Real}, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Bool, Bool}, sparams=svec(), method=(::Type{RipQP.IterData{T, S} where S where T<:Real})(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=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), Any, typeof(Base.:(-)), AbstractArray{Float64, 1}, Any}, limit=3), nothing, 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, 0x7632ae7ed0e0)[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=0x000000000000127a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{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.QuadraticModel{T0, S0, M1, M2} where M2 where M1 where S0<:AbstractArray{T0, 1} where T0<:Real, RipQP.QM_IntData, RipQP.InputConfig{I} where I<:Integer, RipQP.InputTol{T0, Int64} where T0<:Real, RipQP.ScaleDataQP{T, S} where S<:(AbstractArray{T, 1} where T<:Real) where T<:Real, RipQP.StartingPointData{T, S} where S where T<:Real, RipQP.StopCrit{Float64}, RipQP.Counters, Bool, RipQP.QM_FloatData{T, S, M1, M2} where M2 where M1 where S where T<:Real, RipQP.Tolerances{T} where T<:Real, RipQP.QM_FloatData{T, S, _A, _B} where _B where _A where S<:(AbstractArray{T, 1} where T<:Real) where T<:Real, RipQP.Tolerances{T} where T<:Real, Union{RipQP.PreallocatedFloatData{T, _A, _B, _C, _D} where _D<:RipQP.PreallocatedData{T, _A} where _C<:RipQP.DescentDirectionAllocs{T, _A} where _B<:RipQP.AbstractResiduals{T, _A} where _A, RipQP.PreallocatedFloatData{T, S, _B, _C, _D} where _D<:RipQP.PreallocatedData{T, S} where _C<:RipQP.DescentDirectionAllocs{T, S} where _B<:RipQP.AbstractResiduals{T, S} where S} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ebc328e0)[Core.MethodMatch(spec_types=Tuple{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}, QMType, RipQP.QM_IntData, RipQP.InputConfig{Int64}, RipQP.InputTol{T, Int64}, Sd, RipQP.StartingPointData{T1, S1}, RipQP.StopCrit{Float64}, RipQP.Counters, Bool, QMfd1, RipQP.Tolerances{T1}, QMfd2, RipQP.Tolerances{T}, Pfd} where Pfd<:(RipQP.PreallocatedFloatData{T1, S1, _B, _C, _D} where _D<:RipQP.PreallocatedData{T1, S1} where _C<:RipQP.DescentDirectionAllocs{T1, S1} where _B<:RipQP.AbstractResiduals{T1, S1}) where QMfd2<:(RipQP.QM_FloatData{T, S, _A, _B} where _B<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where _A<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where QMfd1<:(RipQP.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 Sd<:RipQP.ScaleDataQP{T, S} where QMType<:(QuadraticModels.QuadraticModel{T, S, M1, M2} where M2 where M1) where S<:AbstractArray{T, 1} where T<:Real, sparams=svec(T<:Real, S<:AbstractArray{T<:Real, 1}, Int64, QMType<:QMType<:(QuadraticModels.QuadraticModel{T<:Real, S<:AbstractArray{T<:Real, 1}, M1, M2} where M2 where M1), Sd<:Sd<:RipQP.ScaleDataQP{T<:Real, S<:AbstractArray{T<:Real, 1}}, Float64, T1<:Real, S1, QMfd1<:QMfd1<:(RipQP.QM_FloatData{T1<:Real, S1, M1, M2} where M2<:Union{AbstractArray{T1<:Real, 2}, LinearOperators.AbstractLinearOperator{T1<:Real}} where M1<:Union{AbstractArray{T1<:Real, 2}, LinearOperators.AbstractLinearOperator{T1<:Real}}), QMfd2<:QMfd2<:(RipQP.QM_FloatData{T<:Real, S<:AbstractArray{T<:Real, 1}, _A, _B} where _B<:Union{AbstractArray{T<:Real, 2}, LinearOperators.AbstractLinearOperator{T<:Real}} where _A<:Union{AbstractArray{T<:Real, 2}, LinearOperators.AbstractLinearOperator{T<:Real}}), Pfd<:Pfd<:(RipQP.PreallocatedFloatData{T1<:Real, S1, _B, _C, _D} where _D<:RipQP.PreallocatedData{T1<:Real, S1} where _C<:RipQP.DescentDirectionAllocs{T1<:Real, S1} where _B<:RipQP.AbstractResiduals{T1<:Real, S1})), method=(::Type{RipQP.RipQPDoubleSolver{T, S, I, QMType, Sd, Tsc, T1, S1, QMfd1, QMfd2, Pfd} where Pfd where QMfd2 where QMfd1 where S1 where T1 where Tsc where Sd where QMType where I where S where T})(QMType, RipQP.QM_IntData, RipQP.InputConfig{I}, RipQP.InputTol{T, I}, Sd, RipQP.StartingPointData{T1, S1}, RipQP.StopCrit{Tsc}, RipQP.Counters, Bool, QMfd1, RipQP.Tolerances{T1}, QMfd2, RipQP.Tolerances{T}, Pfd) where {T, S, I, QMType<:QuadraticModels.AbstractQuadraticModel{T, S}, Sd<:RipQP.ScaleData{T, S}, Tsc<:Real, T1, S1, 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}}), 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}}), 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})}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, 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{T, S}} where S<:(AbstractArray{T, 1} where T) where T, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dfa68820)[Core.MethodMatch(spec_types=Tuple{NLPModels.var"##_#43", AbstractArray{T, 1} where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T, Any, Any, Any, Any, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T, Any, Any, Any, Any, Any, Any, Any, Any, Any, Type{NLPModels.NLPModelMeta{T, S}}, Int64} where S<:(AbstractArray{T, 1} where T) where T, sparams=svec(T, S), 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=0x0000000000009849, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._tuple_error), Type{var"#s181"} where var"#s181"<:Tuple{AbstractArray{Float64, 1}, AbstractArray{Float64, 1}}, Tuple{AbstractArray{Float64, 1}, AbstractArray{Float64, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632de6a0ee0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._tuple_error), Type{var"#s181"} where var"#s181"<:Tuple{AbstractArray{Float64, 1}, AbstractArray{Float64, 1}}, Tuple{AbstractArray{Float64, 1}, AbstractArray{Float64, 1}}}, sparams=svec(), method=_tuple_error(Type, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000394, 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, 0x7632ece5c580)[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=0x000000000000032d, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{LinearOperators.var"##LinearOperator#14", Type{Array{T, 1}} where T, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, Type, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##2#PreconditionerData##3"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Nothing, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b6aa4d60)[Core.MethodMatch(spec_types=Tuple{LinearOperators.var"##LinearOperator#14", Type{Array{T, 1}} where T, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, Type, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##2#PreconditionerData##3"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Nothing, Nothing}, sparams=svec(T, 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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.merge_fallback), NamedTuple{(:ap,), var"#s185"} where var"#s185"<: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, 0x7632ae52f640)[Core.MethodMatch(spec_types=Tuple{typeof(Base.merge_fallback), NamedTuple{(:ap,), var"#s185"} where var"#s185"<: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=0x0000000000001ae5, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{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.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, Any, Any, Bool, Bool, RipQP.Regularization{T} where T<:Real, Array{T, 1} where T<:Real, Any, RipQP.MatrixTools{T} where T<:Real, Any, Int64, Any, Any, Any, Any, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ad2c4aa0)[Core.MethodMatch(spec_types=Tuple{Type{RipQP.PreallocatedDataK2Krylov{T, S, M, MT, Pr, Ksol} where Ksol where Pr<:(RipQP.PreconditionerData{T, S} where S where T<:Real) where MT<:Union{Int64, RipQP.MatrixTools{T}} where M where S where T}, Pr, S, S, Bool, Bool, RipQP.Regularization{T}, Array{T, 1}, M, MT, Ksol, Int64, Real, Real, Real, Real, Int64} where Ksol<:(Krylov.KrylovWorkspace{T, FC, S} where S where FC where T) where Pr<:(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) where MT<: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, sparams=svec(T<:Real, S, 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}, MT<:Union{Int64, RipQP.MatrixTools{T<:Real}}, Pr<:(RipQP.PreconditionerData{T, S} where S where T<:Real), Ksol<:(Krylov.KrylovWorkspace{T, FC, S} where S where FC where T)), method=(::Type{RipQP.PreallocatedDataK2Krylov{T, S, M, MT, Pr, Ksol} where Ksol where Pr where MT where M where S where T})(Pr, S, S, Bool, Bool, RipQP.Regularization{T}, Array{T, 1}, M, MT, Ksol, Int64, T, T, T, T, Int64) where {T<:Real, S, M<:Union{AbstractArray{T, 2}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, MT<:Union{Int64, RipQP.MatrixTools{T}}, Pr<:(RipQP.PreconditionerData{T, S} where S where T<:Real), Ksol<:(Krylov.KrylovWorkspace{T, FC, S} where S where FC where T)}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{Any, Int64}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ec52dca0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{Any, Int64}, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006ad, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{AbstractArray{var"#s682", 1} where var"#s682", AbstractArray{var"#s682", 1} where var"#s682"}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ded7fd40)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{AbstractArray{var"#s682", 1} where var"#s682", AbstractArray{var"#s682", 1} where var"#s682"}}}, 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{BoundsError}, 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), Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632df87f1c0)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, 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), 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{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, 0x7632b92cd280)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), 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=iterate(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006a2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Base.Generator{Base.UnitRange{Int64}, F} where F<:(Base.var"#191#192"{_A, NamedTuple{(), Tuple{}}} where _A)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ca721d40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Base.Generator{Base.UnitRange{Int64}, F} where F<:(Base.var"#191#192"{_A, NamedTuple{(), Tuple{}}} where _A)}, sparams=svec(), method=iterate(Base.Generator{I, F} where F where I, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000044b, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Dict{K, V} where V where K}, 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, 0x7632ae5c1880)[Core.MethodMatch(spec_types=Tuple{Type{Base.Dict{K, V} where V where K}, 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=(::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=0x0000000000003598, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.RefValue{typeof(Base.min)}}, typeof(Base.min)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e1855bc0)[Core.MethodMatch(spec_types=Tuple{Type{Base.RefValue{typeof(Base.min)}}, typeof(Base.min)}, sparams=svec(typeof(Base.min)), method=(::Type{Base.RefValue{T}})(Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000cf4, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(QuadraticModels.unconstrained_reductions!), QuadraticModels.QuadraticModelPresolveData{T, S} where S where T, 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, 0x7632b6606980)[Core.MethodMatch(spec_types=Tuple{typeof(QuadraticModels.unconstrained_reductions!), QuadraticModels.QuadraticModelPresolveData{T, S}, Array{QuadraticModels.PresolveOperation{T, S}, 1}} where S where T<:Real, sparams=svec(T<:Real, S), method=unconstrained_reductions!(QuadraticModels.QuadraticModelPresolveData{T, S}, Array{QuadraticModels.PresolveOperation{T, S}, 1}) where {T, S}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000098de, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.update_pad!), 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.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.Counters}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bb5763e0)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.update_pad!), 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.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} where T<:Real, sparams=svec(T<:Real), method=update_pad!(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) where {T<:Real}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, 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{AbstractArray{Float64, 1}, Float64}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632da403080)[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{AbstractArray{Float64, 1}, 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=0x00000000000048f4, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.steprangelen_hp), Type{Float64}, Float64, Float64, Int64, Any, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632b61fc8e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.steprangelen_hp), Type{Float64}, Float64, Float64, Int64, Integer, Int64}, sparams=svec(), method=steprangelen_hp(Type{Float64}, Union{AbstractFloat, Tuple{AbstractFloat, AbstractFloat}}, Union{AbstractFloat, Tuple{AbstractFloat, AbstractFloat}}, Integer, Integer, Integer), fully_covers=false), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002fca, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IteratorSize}, Type{NTuple{6, Pair{Symbol, Int64}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632b9acabe0)[ Core.MethodMatch(spec_types=Tuple{Type{Base.IteratorSize}, Type{NTuple{6, Pair{Symbol, Int64}}}}, sparams=svec(), method=(::Type{Base.IteratorSize})(Type{var"#s66"} where var"#s66"<:Tuple), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000469, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LinearAlgebra.dot), AbstractArray{Float64, 1}, FillArrays.Fill{Float64, 1, Tuple{Base.OneTo{Int64}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(6, 0x7632cce133b0)[ Core.MethodMatch(spec_types=Tuple{typeof(LinearAlgebra.dot), FillArrays.AbstractFill{Float64, 1, Axes} where Axes, FillArrays.Fill{Float64, 1, Tuple{Base.OneTo{Int64}}}}, sparams=svec(), method=dot(FillArrays.AbstractFill{T, 1, Axes} where Axes where T, FillArrays.AbstractFill{T, 1, Axes} where Axes where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(LinearAlgebra.dot), AbstractArray{Float64, 1}, FillArrays.Fill{Float64, 1, Tuple{Base.OneTo{Int64}}}}, sparams=svec(), method=dot(AbstractArray{T, 1} where T, FillArrays.AbstractFill{T, 1, Axes} where Axes where T), fully_covers=true), #, #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000981b, max_world=0xffffffffffffffff), ambig=true), Base.Compiler.MethodMatchKey(sig=Tuple{Core.EvalInto, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cd0a3700)[Core.MethodMatch(spec_types=Tuple{Core.EvalInto, Any}, sparams=svec(), method=EvalInto(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000000c7, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(|)), UInt64, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7632deb66720)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.:(|)), UInt64, Base.Missing}, sparams=svec(), method=|(Integer, Base.Missing), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.:(|)), UInt64, UInt64}, sparams=svec(UInt64), method=|(T, T) where {T<:Union{Int128, Int16, Int32, Int64, Int8, UInt128, UInt16, UInt32, UInt64, UInt8}}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.:(|)), UInt64, Integer}, sparams=svec(), method=|(Integer, Integer), fully_covers=false), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004b46, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s181"} where var"#s181"<:Number, Real}, limit=3), nothing, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.keys), NamedTuple{(:status, :iter, :elapsed_time, :solver_specific), var"#s185"} where var"#s185"<:Tuple{Symbol, Int64, Float64, Union{Base.Dict{Symbol, Any}, 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, 0x7632dec707c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.keys), NamedTuple{(:status, :iter, :elapsed_time, :solver_specific), var"#s185"} where var"#s185"<:Tuple{Symbol, Int64, Float64, Union{Base.Dict{Symbol, Any}, Base.Dict{Symbol, QuadraticModels.PresolvedQuadraticModel{Float64, Array{Float64, 1}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}}}}}}, sparams=svec((:status, :iter, :elapsed_time, :solver_specific)), method=keys(NamedTuple{names, T} where T<:Tuple) where {names}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001af2, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), Any, AbstractArray{Float64, 1}, Base.Broadcast.Broadcasted{var"#s185", Nothing, typeof(RipQP.safe_boundary), var"#s185"} where var"#s185"<:Tuple{AbstractArray{Float64, 1}} where var"#s185"<:Base.Broadcast.BroadcastStyle}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cbd57c80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.Broadcast.BroadcastStyle, AbstractArray{Float64, 1}, Base.Broadcast.Broadcasted{var"#s185", Nothing, typeof(RipQP.safe_boundary), var"#s185"} where var"#s185"<:Tuple{AbstractArray{Float64, 1}} where var"#s185"<:Base.Broadcast.BroadcastStyle}, sparams=svec(), method=materialize!(Base.Broadcast.BroadcastStyle, Any, Base.Broadcast.Broadcasted{var"#s683", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s683"), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a03, 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, 0x7632cb33f900)[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=0x0000000000009849, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.print), Base.GenericIOBuffer{Memory{UInt8}}, Real}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s185"} where var"#s185"<:Tuple{FillArrays.Ones{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}(4, 0x7632deab7b20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s185"} where var"#s185"<:Tuple{FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}, Array{T, 1} where T<:Number}}, 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=0x0000000000004945, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(StaticArrays._norm), StaticArraysCore.Size{S} where S, StaticArraysCore.StaticArray{S, Float64, 1} where S<:Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cb7b7400)[Core.MethodMatch(spec_types=Tuple{typeof(StaticArrays._norm), StaticArraysCore.Size{S} where S, StaticArraysCore.StaticArray{S, Float64, 1} where S<:Tuple}, sparams=svec(S), method=_norm(StaticArraysCore.Size{S}, StaticArraysCore.StaticArray{S, T, N} where N where T where S<:Tuple) where {S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009838, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.maybeview), AbstractArray{T, 1} where T, Array{Int64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632baccada0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.maybeview), AbstractArray{T, 1} where T, 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=0x0000000000002f07, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.print_to_string), String, Type{Tuple{1}}, String, Int64, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dc44b680)[Core.MethodMatch(spec_types=Tuple{typeof(Base.print_to_string), String, Type{Tuple{1}}, String, Int64, String}, sparams=svec(), method=print_to_string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003ea0, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(*)), var"#s185"} where var"#s185"<:Tuple{Int64, Array{R, 1} where R}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b91df780)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(*)), var"#s185"} where var"#s185"<:Tuple{Int64, Array{R, 1} where R}, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000029f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(DiffResults.tuple_eltype), Tuple, Type{Base.Val{1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ec815900)[Core.MethodMatch(spec_types=Tuple{typeof(DiffResults.tuple_eltype), Tuple, Type{Base.Val{1}}}, sparams=svec(1), method=tuple_eltype(Tuple, Type{Base.Val{i}}) where {i}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009827, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(<)), Any, Int64}, limit=3), nothing, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.map), Base.Iterators.var"#iterate##0#iterate##1", Tuple{Array{Int64, 1}, Array{T, 1} where T<:Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ad18f100)[Core.MethodMatch(spec_types=Tuple{typeof(Base.map), Base.Iterators.var"#iterate##0#iterate##1", Tuple{Array{Int64, 1}, Array{T, 1} where T<:Real}}, sparams=svec(), method=map(Any, Tuple{Any, Any}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006e2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s181", var"#s185"} where var"#s185"<:Tuple{Base.RefValue{ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{Nothing}}, Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}} where var"#s181"<: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, 0x7632cb12d600)[Core.MethodMatch(spec_types=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s181", var"#s185"} where var"#s185"<:Tuple{Base.RefValue{ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{Nothing}}, Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}} where var"#s181"<: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=0x000000000000181c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(DelimitedFiles.writedlm_cell), Base.GenericIOBuffer{Memory{UInt8}}, Real, Char, Char}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632b8ab49a0)[ Core.MethodMatch(spec_types=Tuple{typeof(DelimitedFiles.writedlm_cell), Base.GenericIOBuffer{Memory{UInt8}}, AbstractFloat, Char, Char}, sparams=svec(), method=writedlm_cell(IO, AbstractFloat, Any, Any), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(DelimitedFiles.writedlm_cell), Base.GenericIOBuffer{Memory{UInt8}}, Real, Char, Char}, sparams=svec(), method=writedlm_cell(IO, Any, Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000098e0, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.keys), NamedTuple{(:S,), var"#s185"} where var"#s185"<:Tuple{Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632eaca18a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.keys), NamedTuple{(:S,), var"#s185"} where var"#s185"<:Tuple{Any}}, sparams=svec((:S,)), method=keys(NamedTuple{names, T} where T<:Tuple) where {names}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001af2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{ForwardDiff.Dual{_A, V, N} where N where V} where _A, Float64, Tuple{Bool}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632b9949660)[ Core.MethodMatch(spec_types=Tuple{Type{ForwardDiff.Dual{_A, V, N} where N where V} where _A, Float64, Tuple{Bool}}, sparams=svec(_A), method=(::Type{ForwardDiff.Dual{T, V, N} where N where V})(Any, Tuple) where {T}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009830, 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"#s185"} where var"#s185"<:Tuple{Int64, Array{R, 1} where R}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b90f3fe0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.axes), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(*)), var"#s185"} where var"#s185"<:Tuple{Int64, 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=0x000000000000491a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setproperty!), QuadraticModels.QuadraticModelPresolveData{T, S} where S where T, Symbol, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632aee6c1a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.setproperty!), QuadraticModels.QuadraticModelPresolveData{T, S} where S where T, Symbol, Bool}, sparams=svec(), method=setproperty!(Any, Symbol, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000002a0, 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), Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b7d5e060)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Base.Iterators.Rest{I, Int64} where I<:(Array{Tv, 2} where Tv<:Real), Int64}, sparams=svec(), method=iterate(Base.Iterators.Rest{I, S} where S where I, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000194f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.length), Tuple{String, Number, String, Number, String}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ea939de0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.length), Tuple{String, Number, String, Number, String}}, sparams=svec(), method=length(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000068c, 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, 0x7632d920f260)[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=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{RipQP.K2LDLParams{T, Fact} where Fact where T}, RipQP.LDLFact, Float64, Float64, Float64, Float64, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cbdcc240)[Core.MethodMatch(spec_types=Tuple{Type{RipQP.K2LDLParams{T, Fact} where Fact where T}, RipQP.LDLFact, Float64, Float64, Float64, Float64, Bool}, sparams=svec(Float64), method=(::Type{RipQP.K2LDLParams{T, Fact} where Fact where T})(RipQP.AbstractFactorization, T, T, T, T, Bool) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{ft} where ft<:(Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.sqrt), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R<:Real}), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.sqrt), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R<:Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632d9b996e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.sqrt), var"#s185"} where var"#s185"<: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}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.sqrt), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R<:Real}} where T<:(Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.sqrt), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R<:Real}), sparams=svec(T), method=convert(Type{T}, T) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000036c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), Any, Any, Base.RefValue{typeof(Base.getindex)}, Any, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632db7296a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Base.Broadcast.BroadcastStyle, F, Base.RefValue{typeof(Base.getindex)}, Any, Int64} 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.getindex)}, Any, Int64}, sparams=svec(F), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a9e, 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, 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, 0x7632e166f4c0)[Core.MethodMatch(spec_types=Tuple{typeof(QuadraticModels.postsolve!), QuadraticModels.PresolvedData{T, S}, QuadraticModels.QMSolution{S, V} where V, 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, QuadraticModels.QMSolution{S, V} where V) where {T, S}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000098de, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.factorize_K2!), LinearAlgebra.Symmetric{Float64, M} where M<:AbstractArray{Float64, 2}, RipQP.LDLFactorizationData{T} where T, Any, SparseArrays.SparseVector{Float64, Int64}, Array{Int64, 1}, RipQP.Regularization{Float64}, AbstractArray{T, 1} where T<:Real, AbstractArray{T, 1} where T<:Real, 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, 0x7632ac892460)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.factorize_K2!), LinearAlgebra.Symmetric{Float64, M} where M<:AbstractArray{Float64, 2}, RipQP.LDLFactorizationData{Float64}, AbstractArray{Float64, 1}, SparseArrays.SparseVector{Float64, Int64}, Array{Int64, 1}, RipQP.Regularization{Float64}, AbstractArray{Float64, 1}, AbstractArray{Float64, 1}, AbstractArray{Float64, 1}, AbstractArray{Float64, 1}, Array{Int64, 1}, Array{Int64, 1}, Int64, Int64, RipQP.Counters, Bool}, sparams=svec(Float64, Float64), method=factorize_K2!(LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4715", 2} where var"#s4715"<: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=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Array{StaticArrays.SOneTo{1}, 1}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632db89e720)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Array{StaticArrays.SOneTo{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.Broadcast.combine_eltypes), typeof(Base.:(/)), Tuple{FillArrays.AbstractZeros{var"#s682", 1, Axes} where Axes where var"#s682", Array{T, 1} where T<:Number}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632daf13da0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_eltypes), typeof(Base.:(/)), Tuple{FillArrays.AbstractZeros{var"#s682", 1, Axes} where Axes where var"#s682", Array{T, 1} where T<:Number}}, sparams=svec(), method=combine_eltypes(Any, Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000049f2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), RipQP.ScaleDataLP{T, S} where S where T<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cbc96700)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), RipQP.ScaleDataLP{T, S} where S where T<:Real, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000029f, 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, 0x7632cac4a8a0)[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=0x0000000000001125, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), 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, 0x7632ea99f980)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), 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=Typeof(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000028, 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}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ccbda080)[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}}}, 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{LinearOperators.AdjointLinearOperator{T, S} where S where T}, LinearOperators.LinearOperator{_A, Int64, F, Ft, Fct, T} where T where Fct<:(LinearOperators.var"#opDiagonal##2#opDiagonal##3"{typeof(Base.conj), var"#s185"} where var"#s185"<:AbstractArray{T, 1} where T) where Ft<:(LinearOperators.var"#opDiagonal##0#opDiagonal##1"{var"#s185"} where var"#s185"<:AbstractArray{T, 1} where T) where F<:(LinearOperators.var"#opDiagonal##0#opDiagonal##1"{var"#s185"} where var"#s185"<:AbstractArray{T, 1} where T) where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ec201ae0)[Core.MethodMatch(spec_types=Tuple{Type{LinearOperators.AdjointLinearOperator{T, S} where S where T}, LinearOperators.LinearOperator{_A, Int64, F, Ft, Fct, T} where T where Fct<:(LinearOperators.var"#opDiagonal##2#opDiagonal##3"{typeof(Base.conj), var"#s185"} where var"#s185"<:AbstractArray{T, 1} where T) where Ft<:(LinearOperators.var"#opDiagonal##0#opDiagonal##1"{var"#s185"} where var"#s185"<:AbstractArray{T, 1} where T) where F<:(LinearOperators.var"#opDiagonal##0#opDiagonal##1"{var"#s185"} where var"#s185"<:AbstractArray{T, 1} where T) where _A}, sparams=svec(), method=(::Type{LinearOperators.AdjointLinearOperator{T, S} where S where T})(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LinearAlgebra.ldiv!), SparseArrays.CHOLMOD.Factor{T, Ti} where Ti<:Union{Int32, Int64} where T<:Union{Float32, Float64}, Array{Float32, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(0,), mem=Memory{Any}(0, 0x7632f6b091d0)[]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000000, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), RipQP.K2KrylovParams{Float64, PT, FT} where FT<:typeof(DataType) where PT, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cd16b6c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), RipQP.K2KrylovParams{Float64, PT, FT} where FT<:typeof(DataType) where PT, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000029f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4715", 2} where var"#s4715"<:T) where T}, SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b80111a0)[Core.MethodMatch(spec_types=Tuple{Type{LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4715", 2} where var"#s4715"<:T) where T}, SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv<:Real, Symbol}, sparams=svec(), method=(::Type{LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4715", 2} where var"#s4715"<:T) where T})(AbstractArray{T, 2} where T, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000088db, 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, 0x7632e1858f60)[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=0x000000000000061b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.identity), 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)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632eac4bec0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.identity), 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)}, sparams=svec(), method=identity(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c13, 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, 0x7632b98c0ea0)[ 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=0x00000000000017ca, 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"#s185"} where var"#s185"<:AbstractArray{T, 1} where Float64<:T<:Real, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dd0ac6e0)[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"#s185"} where var"#s185"<: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=0x00000000000048f3, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.iszero)}, var"#s185"} where var"#s185"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool, Bool}, Tuple{Int64, Int64}} where T<:(Array{_A, 2} where _A)}, Base.IteratorsMD.CartesianIndex{2}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(6, 0x7632caec5380)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.iszero)}, Union{}}, Base.IteratorsMD.CartesianIndex{2}}, sparams=svec(T, S), method=_broadcast_getindex(Base.Broadcast.Broadcasted{var"#s683", var"#s682", var"#s681", var"#s680"} where var"#s680"<:Tuple{Ref{Type{T}}, Ref{Type{S}}, Vararg{Any}} where var"#s681" where var"#s682" where var"#s683", Any) where {T, S}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.iszero)}, var"#s185"} where var"#s185"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool, Bool}, Tuple{Int64, Int64}} where T<:(Array{_A, 2} where _A)}, Base.IteratorsMD.CartesianIndex{2}}, sparams=svec(), method=_broadcast_getindex(Base.Broadcast.Broadcasted{var"#s683", var"#s682", var"#s681", var"#s680"} where var"#s680" where var"#s681" where var"#s682" where var"#s683", Any), fully_covers=true), #, #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000049dd, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.increment!), ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T, Base.Val{:neval_cons_nln}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ed0e74a0)[Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.increment!), ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T, Base.Val{:neval_cons_nln}}, sparams=svec(), method=increment!(NLPModels.AbstractNLPModel{T, S} where S where T, Base.Val{:neval_cons_nln}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009849, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isprimitivetype), Type{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b97c3bc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.isprimitivetype), Type{Int64}}, sparams=svec(), method=isprimitivetype(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000521, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), 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, 0x7632afb02da0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), 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=Typeof(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000028, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseArrays.CHOLMOD.allocate_sparse), Int64, Int64, Int64, Bool, Bool, Int64, Type{Float64}, Type{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e9ec8180)[Core.MethodMatch(spec_types=Tuple{typeof(SparseArrays.CHOLMOD.allocate_sparse), Int64, Int64, Int64, Bool, Bool, Int64, Type{Float64}, Type{Int64}}, sparams=svec(Float64), method=allocate_sparse(Integer, Integer, Integer, Bool, Bool, Integer, Type{Tv}, Type{Int64}) where {Tv<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000980f, 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"#s185"}} where var"#s185"<: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}(4, 0x7632e03109a0)[ Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s185"}} where var"#s185"<: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=(::Type{Base.IndexStyle})(Type{var"#s683"} where var"#s683"<:(Base.Broadcast.Broadcasted{var"#s682", var"#s681", F, Args} where Args<:Tuple where F where var"#s681"<:Tuple{Any} where var"#s682")), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000492c, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.update_regu_diagK2!), RipQP.Regularization{T} where T<:Real, Array{var"#s37", 1} where var"#s37"<:Real, Array{Int64, 1}, Real, Int64, RipQP.Counters, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bb4fd860)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.update_regu_diagK2!), RipQP.Regularization{T}, Array{T, 1}, Array{Int64, 1}, Real, Int64, RipQP.Counters, Bool} where T<:Real, sparams=svec(T), method=update_regu_diagK2!(RipQP.Regularization{T}, AbstractArray{T, 1}, Any, T, Int64, RipQP.Counters, Bool) where {T}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, var"#s185", typeof(Base.identity), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R} where var"#s185"<:Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632abd6c2e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, var"#s185", typeof(Base.identity), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R} where var"#s185"<: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=0x0000000000004945, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv<:Real, Tuple{Int64, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e087dca0)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv<:Real, Tuple{Int64, 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{TranscodingStreams.Buffer}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bb1a7a40)[Core.MethodMatch(spec_types=Tuple{Type{TranscodingStreams.Buffer}, Int64}, sparams=svec(), method=(::Type{TranscodingStreams.Buffer})(Integer), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000098e1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), var"#s185"} where var"#s185"<: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, RipQP.var"#PreconditionerData##16#PreconditionerData##17"{var"#s185"} where var"#s185"<:RipQP.FactorizationData{Tlow} where Tlow<:Real, Nothing, Nothing, Int64, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ae9528e0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), var"#s185"} where var"#s185"<: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, RipQP.var"#PreconditionerData##16#PreconditionerData##17"{var"#s185"} where var"#s185"<:RipQP.FactorizationData{Tlow} where Tlow<:Real, Nothing, Nothing, Int64, Int64, Int64}, sparams=svec(_A, Int64, F<:(RipQP.var"#PreconditionerData##16#PreconditionerData##17"{var"#s185"} where var"#s185"<:RipQP.FactorizationData{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=0x0000000000009848, 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, 0x7632b95fe6a0)[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=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Generator{I, F} where F where I}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLPModel{Float64, Array{Float64, 1}, Array{Int64, 1}}, Array{Int64, 1}, Int64}, Array{Int64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632de91ed80)[Core.MethodMatch(spec_types=Tuple{Type{Base.Generator{I, F} where F where I}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLPModel{Float64, Array{Float64, 1}, Array{Int64, 1}}, Array{Int64, 1}, Int64}, Array{Int64, 1}}, sparams=svec(Array{Int64, 1}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLPModel{Float64, Array{Float64, 1}, Array{Int64, 1}}, Array{Int64, 1}, 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=0x0000000000000440, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.typeintersect), Type{Tuple{Any, Any}}, Type{var"#s181"} where var"#s181"<:Tuple{AbstractArray{T, 1} where T<:Real, Array{R, 1} where R<:Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b8dd3c40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.typeintersect), Type{Tuple{Any, Any}}, Type{var"#s181"} where var"#s181"<:Tuple{AbstractArray{T, 1} where T<:Real, Array{R, 1} where R<:Real}}, sparams=svec(), method=typeintersect(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000547, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), RipQP.Regularization{Tlow} where Tlow, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cb2ce5a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), RipQP.Regularization{Tlow} where Tlow, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000029f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.mightalias), SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv<:Real, Array{T, 1} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632dbcedfe0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.mightalias), SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv<:Real, Array{T, 1} where T<:Real}, 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=0x0000000000001352, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(DiffResults.derivative!), ForwardDiff.var"#extract_derivative!##2#extract_derivative!##3"{T} where T, DiffResults.MutableDiffResult{O, V, D} where D<:Tuple where V where O, Array{ForwardDiff.Dual{Tag, T, 1}, 1} where T where Tag, Type{Base.Val{1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ec720840)[Core.MethodMatch(spec_types=Tuple{typeof(DiffResults.derivative!), ForwardDiff.var"#extract_derivative!##2#extract_derivative!##3"{T} where T, DiffResults.MutableDiffResult{O, V, D} where D<:Tuple where V where O, Array{ForwardDiff.Dual{Tag, T, 1}, 1} where T where Tag, Type{Base.Val{1}}}, sparams=svec(1), method=derivative!(Any, DiffResults.MutableDiffResult{O, V, D} where D<:Tuple where V where O, AbstractArray{T, N} where N where T, Type{Base.Val{i}}) where {i}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009827, 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, 0x7632ecd122c0)[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=0x0000000000009849, 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##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, Nothing, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632afaeb360)[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##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, 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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{RipQP.var"##RipQPTripleSolver#129", Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Type{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 where S where T}, QuadraticModels.AbstractQuadraticModel{T0, S0} where S0<:AbstractArray{T0, 1} where T0<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b543ad60)[Core.MethodMatch(spec_types=Tuple{RipQP.var"##RipQPTripleSolver#129", RipQP.InputTol{T0, Int64}, Bool, Bool, I, Bool, Symbol, Bool, RipQP.RipQPTripleParameters{T0, SP1, SP2, SP3, SM1, SM2, SM3} where SM3<:RipQP.SolveMethod where SM2<:RipQP.SolveMethod where SM1<:RipQP.SolveMethod where SP3<:RipQP.SolverParams{T0} where SP2<:(RipQP.SolverParams{T} where T) where SP1<:(RipQP.SolverParams{T} where T), Bool, RipQP.SystemWrite, Bool, Type{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 where S where T}, QuadraticModels.AbstractQuadraticModel{T0, S0}} where I<:Integer where S0<:AbstractArray{T0, 1} where T0<:Real, sparams=svec(T0<:Real, S0<:AbstractArray{T0<:Real, 1}, I<:Integer), method=var"#RipQPTripleSolver#129"(RipQP.InputTol{T0, Int64}, Bool, Bool, I, Bool, Symbol, Bool, RipQP.RipQPTripleParameters{T0, SP1, SP2, SP3, SM1, SM2, SM3} where SM3<:RipQP.SolveMethod where SM2<:RipQP.SolveMethod where SM1<:RipQP.SolveMethod where SP3<:RipQP.SolverParams{T0} where SP2<:(RipQP.SolverParams{T} where T) where SP1<:(RipQP.SolverParams{T} where T), Bool, RipQP.SystemWrite, Bool, Type{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 where S where T}, QuadraticModels.AbstractQuadraticModel{T0, S0}) where {T0<:Real, S0<:AbstractArray{T0, 1}, I<:Integer}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.print_to_string), String, Type, String, Int64, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b8398d60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.print_to_string), String, Type, String, Int64, String}, sparams=svec(), method=print_to_string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003ea0, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.update_K_dynamic!), LinearAlgebra.Symmetric{T, _B} where _B<:AbstractArray{T, 2} where T<:Real, LDLFactorizations.LDLFactorization{Tlow, Int64, Int64, Int64} where Tlow<:Real, RipQP.Regularization{T} where T<:Real, Array{Int64, 1}, RipQP.Counters, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ed304b60)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.update_K_dynamic!), LinearAlgebra.Symmetric{T, _B} where _B<:AbstractArray{T, 2}, LDLFactorizations.LDLFactorization{Tlow, Int64, Int64, Int64}, RipQP.Regularization{Tlow}, Array{Int64, 1}, RipQP.Counters, Bool} where Tlow<:Real where T<:Real, sparams=svec(T<:Real, Tlow<:Real), method=update_K_dynamic!(LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4715", 2} where var"#s4715"<:T), LDLFactorizations.LDLFactorization{Tlow, Ti, Tn, Tp} where Tp<:Integer where Tn<:Integer where Ti<:Integer, RipQP.Regularization{Tlow}, Any, RipQP.Counters, Bool) where {T, Tlow}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.finalizer), typeof(SparseArrays.CHOLMOD.free!), SparseArrays.CHOLMOD.Sparse{T, Int64} where T<:Union{Float32, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b87205a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.finalizer), typeof(SparseArrays.CHOLMOD.free!), SparseArrays.CHOLMOD.Sparse{T, Int64} where T<:Union{Float32, Float64}}, sparams=svec(), method=finalizer(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000041f, 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, 0x7632ded36400)[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=0x0000000000009826, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Float16}, Float64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bb45cc80)[Core.MethodMatch(spec_types=Tuple{Type{Float16}, Float64}, sparams=svec(), method=(::Type{Float16})(Float64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000e20, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), Base.Broadcast.DefaultArrayStyle{1}, 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, 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, 0x7632de6b7fe0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.Broadcast.DefaultArrayStyle{1}, 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, 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"#s683", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s683"), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a03, 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, 0x7632dc19c3a0)[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=0x000000000000984c, 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##2#PreconditionerData##3"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ba7850e0)[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##2#PreconditionerData##3"{RipQP.LDLFactorizationData{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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s185"} where var"#s185"<:Tuple{Array{Int64, 1}, Real}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e09cf2e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s185"} where var"#s185"<:Tuple{Array{Int64, 1}, 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=0x000000000000491c, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Type{QuadraticModels.QuadraticModel{T, S, M1, M2}} where M2 where M1 where S where T, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cbcc7920)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Type{QuadraticModels.QuadraticModel{T, S, M1, M2}} where M2 where M1 where S where T, Symbol}, sparams=svec(), method=getproperty(Type, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000299, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), FillArrays.Fill{T, 1, Axes} where Axes where Float64<:T<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e1bbb820)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), FillArrays.Fill{T, 1, Axes} where Axes where Float64<:T<:Real, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000029f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_typejoin_union), Type}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ecb91f80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_typejoin_union), Type}, sparams=svec(T), method=promote_typejoin_union(Type{T}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000610, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:memory, :droptol), var"#s185"} where var"#s185"<:Tuple{Any, Real}, typeof(LimitedLDLFactorizations.attempt_lldl!), Int64, Array{T, 1} where T<:Real, Array{T, 1} where T<:Real, Array{Ti, 1} where Ti<:Integer, Array{Ti, 1} where Ti<:Integer, Array{T, 1} where T<:Real, Array{Ti, 1} where Ti<:Integer, Array{Ti, 1} where Ti<:Integer, Array{Ti, 1} where Ti<:Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dbecb800)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:memory, :droptol), var"#s185"} where var"#s185"<:Tuple{Any, Real}, 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 Tv<:Real where Ti<:Integer, sparams=svec(Ti<:Integer, Tv<:Real), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, 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=0x0000000000009902, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#cvt1#convert##0"{var"#s181", var"#s185"} where var"#s185"<: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}} where var"#s181"<: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}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632d93a40a0)[Core.MethodMatch(spec_types=Tuple{Base.var"#cvt1#convert##0"{var"#s181", var"#s185"} where var"#s185"<: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}} where var"#s181"<: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}}, Int64}, sparams=svec(var"#s181"<: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}}), method=(::Base.var"#cvt1#convert##0"{T, x})(Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000398, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.typejoin), Type{Pair{Symbol, Array{QuadraticModels.PresolveOperation{Float64, Array{Float64, 1}}, 1}}}, Type{Pair{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, 0x7632e01c7da0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.typejoin), Type{Pair{Symbol, Array{QuadraticModels.PresolveOperation{Float64, Array{Float64, 1}}, 1}}}, Type{Pair{Symbol, QuadraticModels.PresolvedQuadraticModel{Float64, Array{Float64, 1}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}}}}}, sparams=svec(), method=typejoin(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000608, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._maybe_reshape), Base.IndexLinear, Array{Tv, 1} where Tv, 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, 0x7632df50ee00)[Core.MethodMatch(spec_types=Tuple{typeof(Base._maybe_reshape), Base.IndexLinear, Array{Tv, 1} where Tv, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(), method=_maybe_reshape(Base.IndexLinear, AbstractArray{T, N} where N where T, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004804, 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, 0x7632eb68bf20)[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=0x0000000000000440, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), Array{T, N} where N where T, Any, Base.IteratorsMD.CartesianIndex{N} where N}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632daf94860)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Array{T, N} where N where T, Any, Base.IteratorsMD.CartesianIndex{N} where N}, 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=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.UnitRange{Int64}, Int64}}, Type{Bool}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ecfa4d40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(<)), Tuple{Base.UnitRange{Int64}, Int64}}, 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=0x0000000000004915, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{RipQP.var"##RipQPSolver#128", 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.RipQPSolver), QuadraticModels.QuadraticModel{T, S, M1, M2} where M2 where M1 where S where T<:Real, 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, 0x7632b89e2260)[Core.MethodMatch(spec_types=Tuple{RipQP.var"##RipQPSolver#128", 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.QuadraticModel{T, S, M1, M2} where M2 where M1 where S, 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, sparams=svec(T<:Real), method=var"#RipQPSolver#128"(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.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}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.rand), Any}, limit=3), nothing, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.to_index), FillArrays.AbstractFill{T, 1, Axes} where Axes where Float64<:T<:Real, Array{Int64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bb17a500)[Core.MethodMatch(spec_types=Tuple{typeof(Base.to_index), FillArrays.AbstractFill{T, 1, Axes} where Axes where Float64<:T<:Real, Array{Int64, 1}}, sparams=svec(), method=to_index(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000ffb, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{FillArrays.Fill{Float64, 1, Axes}} where Axes<:Tuple{Base.OneTo{T} where T<:Integer}, Float64, Tuple{Base.OneTo{T} where T<:Integer}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632eb9860e0)[ Core.MethodMatch(spec_types=Tuple{Type{FillArrays.Fill{Float64, 1, Axes}}, Float64, Tuple{Base.OneTo{T} where T<:Integer}} where Axes<:Tuple{Base.OneTo{T} where T<:Integer}, sparams=svec(T, N, Axes<:Tuple{Vararg{Base.AbstractUnitRange{T} where T, N}}), method=(::Type{FillArrays.Fill{T, N, Axes}})(T, Axes) where {T, N, Axes<:Tuple{Vararg{Base.AbstractUnitRange{T} where T, N}}}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{FillArrays.Fill{Float64, 1, Axes}}, Float64, Tuple{Base.OneTo{T} where T<:Integer}} where Axes<:Tuple{Base.OneTo{T} where T<:Integer}, sparams=svec(T, N, Axes<:Tuple{Vararg{Base.AbstractUnitRange{T} where T, N}}), method=(::Type{FillArrays.Fill{T, N, Axes}})(Any, Axes) where {T, N, Axes<:Tuple{Vararg{Base.AbstractUnitRange{T} where T, N}}}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000981b, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isbits), Base.SubArray{_A, _B, P, I, false} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ad7a4e80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.isbits), Base.SubArray{_A, _B, P, I, false} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A}, sparams=svec(), method=isbits(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000525, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{ForwardDiff.Partials{_A, _B}} where _B where _A, ForwardDiff.Partials{N, V} where V where N}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632eb434d20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{ForwardDiff.Partials{N, V}}, ForwardDiff.Partials{N, V}} where V where N, sparams=svec(N, V), method=convert(Type{ForwardDiff.Partials{N, V}}, ForwardDiff.Partials{N, V}) where {N, V}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{ForwardDiff.Partials{_A, _B}} where _B where _A, ForwardDiff.Partials{N, V} where V where N}, sparams=svec(_A, _B), method=convert(Type{ForwardDiff.Partials{N, V}}, ForwardDiff.Partials{N, V} where V where N) where {N, V}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009830, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IndexStyle}, Base.BitArray{N} where N}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632e9b85da0)[ Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Base.BitArray{N} where N}, sparams=svec(), method=(::Type{Base.IndexStyle})(AbstractArray{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000fd4, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), 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}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cc338fe0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), 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}, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000029f, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{Union{LinearAlgebra.Symmetric{Float64, SparseArrays.SparseMatrixCSC{Float64, Int64}}, LinearAlgebra.Symmetric{Float64, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}}}, Array{Int64, 1}, Any}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cc924ce0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{Union{LinearAlgebra.Symmetric{Float64, SparseArrays.SparseMatrixCSC{Float64, Int64}}, LinearAlgebra.Symmetric{Float64, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}}}, Array{Int64, 1}, Any}, Int64, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006ae, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unsafe_convert), Type{Int64}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cd5af540)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_convert), Type{Int64}, Int64}, sparams=svec(Int64), method=unsafe_convert(Type{T}, T) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000003a6, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.convert_FloatData), Type{T0} where T0<:Real, RipQP.QM_FloatData{T, S, _A, _B} where _B where _A where S<:(AbstractArray{T, 1} where T<:Real) where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b8ad01e0)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.convert_FloatData), Type{T0} where T0<:Real, RipQP.QM_FloatData{T, S, _A, _B} where _B where _A where S<:(AbstractArray{T, 1} where T<:Real) where T<:Real}, sparams=svec(T0<:Real, T<:Real, S<:(AbstractArray{T, 1} where T<:Real), _A, _B), method=convert_FloatData(Type{T}, RipQP.QM_FloatData{T0, S0, M10, M20}) where {T<:Real, T0<:Real, S0, M10, M20}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, 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"#s185"} where var"#s185"<: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, 0x7632b7544e60)[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"#s185"} where var"#s185"<: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=0x0000000000004a33, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._typed_vcat), Type, Tuple{Array{Ti, 1} where Ti<:Integer, Base.UnitRange{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ca264d60)[Core.MethodMatch(spec_types=Tuple{typeof(Base._typed_vcat), Type, Tuple{Array{Ti, 1} where Ti<:Integer, Base.UnitRange{Int64}}}, sparams=svec(T), method=_typed_vcat(Type{T}, Union{Tuple{Vararg{AbstractArray{T, 1} where T}}, AbstractArray{var"#s185", 1} where var"#s185"<:(AbstractArray{T, 1} where T)}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000139e, 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"#s185"} where var"#s185"<:Tuple{Array{Int64, 1}, Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632e9f5a9a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(>)), var"#s185"} where var"#s185"<:Tuple{Array{Int64, 1}, 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=0x0000000000004945, 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, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ad5beb40)[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, 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=0x00000000000005a1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ReverseDiff.record!), Array{ReverseDiff.AbstractInstruction, 1}, 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{V, D, O} where O<:(ReverseDiff.TrackedArray{V, D, 1, VA, DA} where V<:Real where D<:Real where VA where DA) where D<:Real where V<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ae549820)[Core.MethodMatch(spec_types=Tuple{typeof(ReverseDiff.record!), Array{ReverseDiff.AbstractInstruction, 1}, 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{V, D, O} where O<:(ReverseDiff.TrackedArray{V, D, 1, VA, DA} where V<:Real where D<:Real where VA where DA) where D<:Real where V<:Real}, sparams=svec(ReverseDiff.SpecialInstruction{F, I, O, C} where C where O where I where F), method=record!(Array{ReverseDiff.AbstractInstruction, 1}, Type{InstructionType}, Any...) where {InstructionType}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009844, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Float64, Base.SubArray{T, N, P, I, L} where L where I where P where N where T}}, UInt64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b845e140)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Float64, Base.SubArray{T, N, P, I, L} where L where I where P 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.indexed_iterate), Tuple{SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv, SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ac5332a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv, SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv}, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006ad, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.SimdLoop.simd_index), Any, Any, Any}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.length), 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, 0x7632ead29640)[Core.MethodMatch(spec_types=Tuple{typeof(Base.length), 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=length(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000068c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{NamedTuple{(:last_iter,), T} where T<:Tuple}, Tuple{Bool}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ca416da0)[Core.MethodMatch(spec_types=Tuple{Type{NamedTuple{(:last_iter,), T} where T<:Tuple}, Tuple{Bool}}, sparams=svec((:last_iter,)), method=(::Type{NamedTuple{names, T} where T<:Tuple})(Tuple) where {names}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000019a, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Array{T, 1}} where T<:(QuadraticModels.Row{T} where T<:Real), UndefInitializer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ac3fc440)[Core.MethodMatch(spec_types=Tuple{Type{Array{T, 1}} where T<:(QuadraticModels.Row{T} where T<:Real), UndefInitializer, Int64}, sparams=svec(T<:(QuadraticModels.Row{T} where T<:Real)), method=(::Type{Array{T, 1}})(UndefInitializer, Int64) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000117, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.length), Array{ForwardDiff.Dual{Tag, T, 1}, 1} where Tag where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ece25c00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.length), Array{ForwardDiff.Dual{Tag, T, 1}, 1} where Tag where T}, sparams=svec(T<:(ForwardDiff.Dual{Tag, T, 1} where Tag where T)), method=length(Array{T, 1}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000329, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), Base.RefValue{typeof(Base.:(-))}, Any, Array{T, N} where N where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b6ce36c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), Base.RefValue{typeof(Base.:(-))}, 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=0x0000000000004975, 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{Base.UnitRange{Int64}, Tuple{Bool}, Tuple{Int64}}, Int64}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ec49b560)[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{Base.UnitRange{Int64}, Tuple{Bool}, Tuple{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=0x00000000000048f4, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Int32}, Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632ae966060)[ Core.MethodMatch(spec_types=Tuple{Type{Int32}, Union{Bool, Int128, Int16, Int32, Int64, Int8, UInt128, UInt16, UInt32, UInt64, UInt8}}, sparams=svec(), method=(::Type{Int32})(Union{Bool, Int128, Int16, Int32, Int64, Int8, UInt128, UInt16, UInt32, UInt64, UInt8}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{Int32}, Base.GMP.BigInt}, sparams=svec(Int32), method=(::Type{T})(Base.GMP.BigInt) where {T<:Union{Int128, Int16, Int32, Int64, Int8}}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000060cf, 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, 0x7632ea64b540)[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=0x00000000000009f6, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Base.Generator{Base.UnitRange{Int64}, F} where F<:(Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##2#__cat_offset1!##3"{Tuple{Bool, Bool}, Tuple{Vararg{Int64, N}}, _A}} where _A where N), Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cad1be00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Base.Generator{Base.UnitRange{Int64}, F} where F<:(Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##2#__cat_offset1!##3"{Tuple{Bool, Bool}, Tuple{Vararg{Int64, N}}, _A}} where _A where N), Int64}, sparams=svec(), method=iterate(Base.Generator{I, F} where F where I, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000044b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.eltypes), Tuple{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}(1, 0x7632e0588440)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.eltypes), Tuple{FillArrays.Zeros{Float64, 1, Tuple{Base.OneTo{Int64}}}, Array{T, 1} where T<:Number}}, sparams=svec(), method=eltypes(Tuple{Any, Any}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000049ef, 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{T, 1} where T<:Number)}, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632da6e26c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._getindex), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Number)}, Any}, sparams=svec(), method=_getindex(Tuple{Any}, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000049df, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.write_system), RipQP.SystemWrite, 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, Any, Symbol, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b8ba01e0)[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=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._methods), RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Type{Tuple}, Int64, UInt64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ec108840)[Core.MethodMatch(spec_types=Tuple{typeof(Base._methods), RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LDLFactorizationData{Tlow}} 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=0x00000000000005a9, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.initarray!), Array{Float64, 1}, typeof(Base.abs), typeof(Base.max), Bool, LinearAlgebra.Symmetric{Float64, S} where S<:(AbstractArray{var"#s4715", 2} where var"#s4715"<:Float64)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cb457b80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.initarray!), Array{Float64, 1}, typeof(Base.abs), typeof(Base.max), Bool, LinearAlgebra.Symmetric{Float64, S} where S<:(AbstractArray{var"#s4715", 2} where var"#s4715"<:Float64)}, sparams=svec(Float64), method=initarray!(AbstractArray{T, N} where N, Any, Union{typeof(Base._extrema_rf), typeof(Base.max), typeof(Base.min)}, Bool, AbstractArray{T, N} where N where T) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000005a77, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Nothing, _A, _B, var"#s185"} where var"#s185"<:Tuple where _B where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632cd6c2da0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Nothing, _A, _B, var"#s185"} where var"#s185"<:Tuple where _B 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=0x0000000000004945, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.pointer), SparseArrays.CHOLMOD.Factor{T, Ti} where Ti<:Union{Int32, Int64} where T<:Union{Float32, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b70f0a80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.pointer), SparseArrays.CHOLMOD.Factor{T, Ti} where Ti<:Union{Int32, Int64} where T<:Union{Float32, Float64}}, sparams=svec(T<:Union{Float32, Float64}), method=pointer(SparseArrays.CHOLMOD.Factor{Tv, Ti} where Ti<:Union{Int32, Int64}) where {Tv}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000980f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.check_parent_index_match), 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, 0x7632b87c4640)[Core.MethodMatch(spec_types=Tuple{typeof(Base.check_parent_index_match), Array{T, 1} where T<:Real, Tuple{Base.UnitRange{Int64}}}, sparams=svec(), method=check_parent_index_match(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002e47, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Array{Ti, 1} where Ti<:Integer, Type{Ti} where Ti<:Integer, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632dfd15ea0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Array{Ti, 1} where Ti<:Integer, Type{Ti} where Ti<:Integer, Tuple{Base.OneTo{Int64}}}, sparams=svec(Ti<:Integer), method=similar(AbstractArray{T, N} where N where T, Type{T}, Tuple{Union{Integer, Base.OneTo{T} where T<:Integer}, Vararg{Union{Integer, Base.OneTo{T} where T<:Integer}}}) where {T}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012c6, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IteratorEltype}, Type{Tuple{StaticArraysCore.Dynamic, StaticArraysCore.Dynamic}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632d9598060)[ Core.MethodMatch(spec_types=Tuple{Type{Base.IteratorEltype}, Type{Tuple{StaticArraysCore.Dynamic, StaticArraysCore.Dynamic}}}, sparams=svec(), method=(::Type{Base.IteratorEltype})(Type), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000477, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), Any, typeof(Base.:(<)), AbstractArray{var"#s682", 1} where var"#s682", Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(var"==")), Type, Type{Float32}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cb188f20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.:(var"==")), Type, Type{Float32}}, sparams=svec(), method=var"=="(Type, Type), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000bfb, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.result_style), Base.Broadcast.Unknown, Base.Broadcast.BroadcastStyle}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632cd4293a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.result_style), Base.Broadcast.Unknown, Base.Broadcast.Unknown}, sparams=svec(Base.Broadcast.Unknown), 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.Unknown, Base.Broadcast.BroadcastStyle}, sparams=svec(), method=result_style(Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000497a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{Union{Pair{Symbol, Array{QuadraticModels.PresolveOperation{Float64, Array{Float64, 1}}, 1}}, Pair{Symbol, Nothing}}, Int64}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e186be40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{Union{Pair{Symbol, Array{QuadraticModels.PresolveOperation{Float64, Array{Float64, 1}}, 1}}, Pair{Symbol, Nothing}}, Int64}, Int64, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006ae, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcast_unalias), Array{_A, 1} where _A, Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e0e90e00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcast_unalias), Array{_A, 1} where _A, Real}, sparams=svec(), method=broadcast_unalias(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a0b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(+)), AbstractArray{T, 1} where T<:Real, AbstractArray{T, 1} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632ead69560)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(+)), AbstractArray{T, 1} where T<:Real, AbstractArray{T, 1} where T<:Real}, sparams=svec(typeof(Base.:(+))), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a9d, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Krylov.iteration_count), Any}, limit=3), nothing, 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, 0x7632ecd38e00)[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=0x00000000000006e1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"##mapreduce#731", Base.Colon, Int64, typeof(Base.mapreduce), Base.var"#_bool##0#_bool##1"{typeof(SparseArrays._isnotzero)}, typeof(Base.add_sum), Array{Tv, 2} where Tv<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b78fc180)[Core.MethodMatch(spec_types=Tuple{Base.var"##mapreduce#731", Base.Colon, Int64, typeof(Base.mapreduce), Base.var"#_bool##0#_bool##1"{typeof(SparseArrays._isnotzero)}, typeof(Base.add_sum), Array{Tv, 2} where Tv<:Real}, sparams=svec(), method=var"#mapreduce#731"(Any, Any, typeof(Base.mapreduce), Any, Any, Union{Base.AbstractBroadcasted, AbstractArray{T, N} where N where T}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000005ab7, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Set{Int64}}, Base.UnitRange{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632eaae8420)[Core.MethodMatch(spec_types=Tuple{Type{Base.Set{Int64}}, Base.UnitRange{Int64}}, sparams=svec(Int64), method=(::Type{Base.Set{T}})(Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000365e, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.map), typeof(StaticArrays.unwrap), Tuple{StaticArrays.StaticIndexing{I} where I, Vararg{StaticArrays.StaticIndexing{I} where I}}}, limit=3), nothing, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.typeintersect), Type{Tuple{Any, Any, Any}}, Type{var"#s181"} where var"#s181"<:Tuple{Any, Any, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e0c2cd60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.typeintersect), Type{Tuple{Any, Any, Any}}, Type{var"#s181"} where var"#s181"<:Tuple{Any, Any, Int64}}, sparams=svec(), method=typeintersect(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000547, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{NamedTuple{(:S,), T} where T<:Tuple}, Tuple{Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632eb867540)[Core.MethodMatch(spec_types=Tuple{Type{NamedTuple{(:S,), T} where T<:Tuple}, Tuple{Any}}, sparams=svec((:S,)), method=(::Type{NamedTuple{names, T} where T<:Tuple})(Tuple) where {names}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000019a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Tuple{String, Any, String, Tuple{Base.OneTo{Int64}}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cb3b5b00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Tuple{String, Any, String, Tuple{Base.OneTo{Int64}}}, Int64}, sparams=svec(), method=getindex(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:memory,), Tuple{Int64}}, typeof(LimitedLDLFactorizations.lldl), SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv<:Number, Type{Tv} where Tv<:Number}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b7d4ab00)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:memory,), Tuple{Int64}}, typeof(LimitedLDLFactorizations.lldl), SparseArrays.SparseMatrixCSC{Tv, Int64}, Type{Tf}} where Tf<:Real where Tv<:Number, sparams=svec(Tv<:Number, Int64, Tf<:Real), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(LimitedLDLFactorizations.lldl), SparseArrays.SparseMatrixCSC{Tv, Ti}, Type{Tf}) where {Tv<:Number, Ti<:Integer, Tf<:Real}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009902, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.BroadcastStyle}, Type{Base.RefValue{typeof(SparseMatricesCOO.replace_if_minusinf)}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e08de120)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.BroadcastStyle}, Type{Base.RefValue{typeof(SparseMatricesCOO.replace_if_minusinf)}}}, sparams=svec(Base.RefValue{typeof(SparseMatricesCOO.replace_if_minusinf)}), method=(::Type{Base.Broadcast.BroadcastStyle})(Type{T}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048de, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Expr}, Symbol, Symbol, typeof(Base.:(var"==")), Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632df050ee0)[Core.MethodMatch(spec_types=Tuple{Type{Expr}, Symbol, Symbol, typeof(Base.:(var"==")), Symbol}, 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(Base.:(/)), Base.TwicePrecision{T} where T<:Union{Float16, Float32, Float64}, Base.TwicePrecision{Float32}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ba6aa200)[Core.MethodMatch(spec_types=Tuple{typeof(Base.:(/)), Base.TwicePrecision{T} where T<:Union{Float16, Float32, Float64}, Base.TwicePrecision{Float32}}, sparams=svec(), method=/(Base.TwicePrecision{T} where T, Base.TwicePrecision{T} where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002fc2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Array{T, 1}} where T<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}, UndefInitializer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ae42c680)[Core.MethodMatch(spec_types=Tuple{Type{Array{T, 1}} where T<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}, UndefInitializer, Int64}, sparams=svec(T<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}), method=(::Type{Array{T, 1}})(UndefInitializer, Int64) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000117, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{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 S where T}, RipQP.Point{T, var"#s185"} where var"#s185"<:AbstractArray{T, 1} where T<:Real where T<:Real, Union{RipQP.Residuals{T, var"#s185"} where var"#s185"<:AbstractArray{T, 1} where T<:Real where T<:Real, RipQP.ResidualsHistory{T, var"#s185"} where var"#s185"<:AbstractArray{T, 1} where T<:Real where T<:Real}, Union{RipQP.IterDataCPU{Float64, _A} where _A, RipQP.IterDataGPU{Float64, _A} where _A}, RipQP.DescentDirectionAllocsPC{_A, S} where S<:(AbstractArray{T, 1} where T) where _A<:Real, Union{RipQP.PreallocatedDataK2LDL{Float64, _A, RipQP.LDLFactorizationData{Float64}, SparseArrays.SparseMatrixCSC{Float64, Int64}} where _A, RipQP.PreallocatedDataK2LDL{Float64, _A, RipQP.LDLFactorizationData{Float64}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}} where _A}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b9a73020)[Core.MethodMatch(spec_types=Tuple{Type{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 S where T}, RipQP.Point{Float64, S}, Union{Res, Res}, Union{RipQP.IterDataCPU{Float64, S}, RipQP.IterDataGPU{Float64, S}}, Union{Dda, Dda}, Union{Pad, Pad}} where Pad<:Union{RipQP.PreallocatedDataK2LDL{Float64, S, RipQP.LDLFactorizationData{Float64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}, RipQP.PreallocatedDataK2LDL{Float64, S, RipQP.LDLFactorizationData{Float64}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}}} where Dda<:RipQP.DescentDirectionAllocsPC{Float64, S} where Res<:Union{RipQP.Residuals{Float64, S}, RipQP.ResidualsHistory{Float64, S}} where Pad<:Union{RipQP.PreallocatedDataK2LDL{Float64, S, RipQP.LDLFactorizationData{Float64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}, RipQP.PreallocatedDataK2LDL{Float64, S, RipQP.LDLFactorizationData{Float64}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}}} where Dda<:RipQP.DescentDirectionAllocsPC{Float64, S} where Res<:Union{RipQP.Residuals{Float64, S}, RipQP.ResidualsHistory{Float64, S}} where S<:AbstractArray{T, 1} where T<:Real, sparams=svec(Float64, S<:AbstractArray{T<:Real, 1}, Res<:RipQP.AbstractResiduals{T, S}, Dda<:RipQP.DescentDirectionAllocs{T, S}, Pad<:RipQP.PreallocatedData{T, S}), method=(::Type{RipQP.PreallocatedFloatData{T, S, Res, Dda, Pad} where Pad where Dda where Res where S where T})(RipQP.Point{T, S}, Res, RipQP.IterData{T, S}, Dda, Pad) where {T, S, Res<:RipQP.AbstractResiduals{T, S}, Dda<:RipQP.DescentDirectionAllocs{T, S}, Pad<:RipQP.PreallocatedData{T, S}}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.preprocess_args), FillArrays.Fill{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, 0x7632e1809860)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.preprocess_args), FillArrays.Fill{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=0x0000000000004a12, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._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(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e0b81460)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._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}, sparams=svec(), method=_getindex(Tuple, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000049de, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#__cat_offset1!##2#__cat_offset1!##3"{Tuple{Bool}, Tuple{Int64}, Array{Ti, 1}} where Ti<:Integer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ca91b060)[Core.MethodMatch(spec_types=Tuple{Base.var"#__cat_offset1!##2#__cat_offset1!##3"{Tuple{Bool}, Tuple{Int64}, Array{Ti, 1}} where Ti<:Integer, Int64}, sparams=svec(), method=(::Base.var"#__cat_offset1!##2#__cat_offset1!##3"{catdims, offsets, x})(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000013f6, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Type{Bool}, Base.SubArray{T, 1, P, I, false} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where T, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632ad716960)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Type{Bool}, Base.SubArray{T, 1, P, I, false} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where T, 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=0x00000000000012ae, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.string), String, Type{T} where T<:Union{SparseArrays.LibSuiteSparse.cholmod_dense_struct, SparseArrays.LibSuiteSparse.cholmod_factor_struct, SparseArrays.LibSuiteSparse.cholmod_sparse_struct}, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dc1d29c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.string), String, Type{T} where T<:Union{SparseArrays.LibSuiteSparse.cholmod_dense_struct, SparseArrays.LibSuiteSparse.cholmod_factor_struct, SparseArrays.LibSuiteSparse.cholmod_sparse_struct}, String}, sparams=svec(), method=string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003ea3, 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##6#PreconditionerData##7"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cd7d2c40)[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##6#PreconditionerData##7"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}}, 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=0x0000000000009848, 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, 0x7632cca323e0)[ 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=0x0000000000000bff, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._ntuple), Base.var"#__cat_offset1!##0#__cat_offset1!##1"{var"#s185", Tuple{Bool, Bool}, var"#s185", 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 where var"#s185"<:Tuple where var"#s185"<:Tuple{Any, Any, Vararg{Int64}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632caf46d80)[Core.MethodMatch(spec_types=Tuple{typeof(Base._ntuple), Base.var"#__cat_offset1!##0#__cat_offset1!##1"{var"#s185", Tuple{Bool, Bool}, var"#s185", 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 where var"#s185"<:Tuple where var"#s185"<:Tuple{Any, Any, Vararg{Int64}}, Int64}, sparams=svec(F<:(Base.var"#__cat_offset1!##0#__cat_offset1!##1"{var"#s185", Tuple{Bool, Bool}, var"#s185", 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 where var"#s185"<:Tuple where var"#s185"<:Tuple{Any, Any, Vararg{Int64}})), method=_ntuple(F, Int64) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001816, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LinearAlgebra.ldiv!), LinearAlgebra.Diagonal{T, Array{T, 1}} where T<:Real, AbstractArray{var"#s4715", 2} where var"#s4715"<:Real}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{ft} where ft<:Int64, Array{Ti, 1} where Ti<:Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cc555080)[Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Array{Ti, 1} where Ti<:Integer}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000036c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{RipQP.StopCrit{Float64}, RipQP.QM_FloatData{T, S, _A, _B} where _B where _A where S<:(AbstractArray{T, 1} where T<:Real) where T<:Real, RipQP.QM_IntData, RipQP.Tolerances{T} where T<:Real, Union{RipQP.Residuals{T, var"#s185"} where var"#s185"<:AbstractArray{T, 1} where T<:Real where T<:Real, RipQP.ResidualsHistory{T, var"#s185"} where var"#s185"<: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"#s185"} where var"#s185"<:AbstractArray{T, 1} where T<:Real where T<:Real, Union{RipQP.ScaleDataLP{T, S} where S<:(AbstractArray{T, 1} where T<:Real) where T<:Real, RipQP.ScaleDataQP{T, S} where S<:(AbstractArray{T, 1} where T<:Real) 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, 0x7632ec704220)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{RipQP.StopCrit{Float64}, RipQP.QM_FloatData{T, S, _A, _B} where _B where _A where S<:(AbstractArray{T, 1} where T<:Real) where T<:Real, RipQP.QM_IntData, RipQP.Tolerances{T} where T<:Real, Union{RipQP.Residuals{T, var"#s185"} where var"#s185"<:AbstractArray{T, 1} where T<:Real where T<:Real, RipQP.ResidualsHistory{T, var"#s185"} where var"#s185"<: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"#s185"} where var"#s185"<:AbstractArray{T, 1} where T<:Real where T<:Real, Union{RipQP.ScaleDataLP{T, S} where S<:(AbstractArray{T, 1} where T<:Real) where T<:Real, RipQP.ScaleDataQP{T, S} where S<:(AbstractArray{T, 1} where T<:Real) 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=0x00000000000006ad, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(FillArrays.broadcasted_fill), typeof(Base.:(<)), Union{FillArrays.AbstractOnes{Float64, 1, Axes} where Axes, FillArrays.AbstractZeros{Float64, 1, Axes} where Axes, FillArrays.Fill{Float64, 1, Axes} where Axes}, Union{FillArrays.AbstractOnes{Float64, 1, Axes} where Axes, FillArrays.AbstractZeros{Float64, 1, Axes} where Axes, FillArrays.Fill{Float64, 1, Axes} where Axes}, Bool, Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e10f3780)[Core.MethodMatch(spec_types=Tuple{typeof(FillArrays.broadcasted_fill), typeof(Base.:(<)), Union{FillArrays.AbstractOnes{Float64, 1, Axes} where Axes, FillArrays.AbstractZeros{Float64, 1, Axes} where Axes, FillArrays.Fill{Float64, 1, Axes} where Axes}, Union{FillArrays.AbstractOnes{Float64, 1, Axes} where Axes, FillArrays.AbstractZeros{Float64, 1, Axes} where Axes, FillArrays.Fill{Float64, 1, Axes} where Axes}, Bool, Tuple}, sparams=svec(), method=broadcasted_fill(Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000981b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), AbstractArray{T, 1} where Float64<:T<:Real, Base.Broadcast.Broadcasted{Style, Nothing, typeof(OperatorScaling.return_one_if_zero), Args} where Args<:Tuple where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632ca091060)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), AbstractArray{T, 1} where Float64<:T<:Real, Base.Broadcast.Broadcasted{Style, Nothing, typeof(OperatorScaling.return_one_if_zero), Args} where Args<:Tuple where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, sparams=svec(), method=materialize!(Any, Base.Broadcast.Broadcasted{var"#s683", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s683"), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a02, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{LinearOperators.var"##_#1", 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##4#PreconditionerData##5"{var"#s185"} where var"#s185"<:RipQP.FactorizationData{Tlow} where Tlow<:Real, Nothing, Nothing, Int64, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632d99472e0)[Core.MethodMatch(spec_types=Tuple{LinearOperators.var"##_#1", 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##4#PreconditionerData##5"{var"#s185"} where var"#s185"<:RipQP.FactorizationData{Tlow} where Tlow<:Real, Nothing, Nothing, Int64, Int64, Int64}, sparams=svec(Float64, Int64, F<:(RipQP.var"#PreconditionerData##4#PreconditionerData##5"{var"#s185"} where var"#s185"<:RipQP.FactorizationData{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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.StepRange{var"#s185", _A}} where _A where var"#s185"<:Signed, Signed, Any, Signed}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b9855480)[Core.MethodMatch(spec_types=Tuple{Type{Base.StepRange{var"#s185", _A}} where _A where var"#s185"<:Signed, Signed, Any, Signed}, sparams=svec(var"#s185"<:Signed, _A), method=(::Type{Base.StepRange{T, S}})(Any, Any, Any) where {T, S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000089d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{ft} where ft<:Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632da565e20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Real}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000036c, 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, 0x7632b8d06d80)[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=0x000000000000029f, 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, Array{_A, 1} where _A}, limit=1), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632aba5f760)[ 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, Array{_A, 1} where _A}, sparams=svec(), method=copyto!(AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012e4, 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.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, 0x7632afaea6a0)[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.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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), Base.SubArray{T, 1, P, I, L} where L where I where P where T, Any, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632e9c72660)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Base.SubArray{var"#s16", 1, P, I, true} where I where P where var"#s16", Any, Int64}, sparams=svec(), method=setindex!(Base.SubArray{var"#s16", 1, P, I, true} where I where P where var"#s16", Any, Int64), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Base.SubArray{T, 1, P, I, L} where L where I where P where T, Any, Int64}, sparams=svec(T, 1), method=setindex!(Base.SubArray{T, N, P, I, L} where L where I where P, Any, Vararg{Int64, N}) where {T, N}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002ebb, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcast_shape), Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dea88ea0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcast_shape), Tuple}, sparams=svec(), method=broadcast_shape(Tuple), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004988, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real), Base.IteratorsMD.CartesianIndex{2}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632de3867e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{T, 1} where T<:Real), Base.IteratorsMD.CartesianIndex{2}}, sparams=svec(), method=_broadcast_getindex(Base.Broadcast.Extruded{T, K, D} where D where K where T, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000049d6, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Pair{Symbol, Nothing}}, Symbol, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632eb186180)[Core.MethodMatch(spec_types=Tuple{Type{Pair{Symbol, Nothing}}, Symbol, Nothing}, sparams=svec(Symbol, Nothing), method=(::Type{Pair{A, B}})(Any, Any) where {A, B}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002e23, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LinearOperators.opDiagonal), Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ebcc9ee0)[Core.MethodMatch(spec_types=Tuple{typeof(LinearOperators.opDiagonal), AbstractArray{T, 1}} where T, sparams=svec(T), method=opDiagonal(AbstractArray{T, 1}) where {T}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), Base.SubArray{Any, 1, P, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, false} where P<:(Array{var"#s4715", 1} where var"#s4715"<:Float64)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b81a0fa0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), Base.SubArray{Any, 1, P, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, false} where P<:(Array{var"#s4715", 1} where var"#s4715"<:Float64)}, sparams=svec(), method=combine_styles(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004972, 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, Array{T, N} where N where T}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cb51dd80)[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, Array{T, N} where N where T}, 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=0x00000000000048f4, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.RefValue{typeof(Base.abs)}, Any}}, UInt64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632db48b420)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.RefValue{typeof(Base.abs)}, 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.combine_styles), Base.SubArray{Float64, 1, Array{Float64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.Broadcast.Broadcasted{var"#s683", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s683"}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632eaedcb20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), Base.SubArray{Float64, 1, Array{Float64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.Broadcast.Broadcasted{var"#s683", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s683"}, sparams=svec(), method=combine_styles(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004974, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Array{T, 2} where T, Any}, limit=3), nothing, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Array{Tlow, 1}} where Tlow<:Union{Float32, Float64}, UndefInitializer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dbe4f360)[Core.MethodMatch(spec_types=Tuple{Type{Array{Tlow, 1}} where Tlow<:Union{Float32, Float64}, UndefInitializer, Int64}, sparams=svec(Tlow<:Union{Float32, Float64}), method=(::Type{Array{T, 1}})(UndefInitializer, Int64) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000117, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.axes1), FillArrays.Zeros{_A, 1, Tuple{Base.OneTo{Int64}}} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632cdebb160)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.axes1), FillArrays.Zeros{_A, 1, Tuple{Base.OneTo{Int64}}} where _A}, sparams=svec(), method=axes1(AbstractArray{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000126b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eltype), Array{T, 1} where T}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cb456620)[Core.MethodMatch(spec_types=Tuple{typeof(Base.eltype), Array{T, 1} where T}, sparams=svec(), method=eltype(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000127a, 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, 0x7632eb0c69a0)[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.Broadcast.instantiate), Base.Broadcast.Broadcasted{var"#s185", Tuple{Base.OneTo{Int64}}, typeof(Base.identity), var"#s185"} where var"#s185"<:Tuple where var"#s185"<:Base.Broadcast.BroadcastStyle}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{Type{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.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, Any, Bool, Bool, RipQP.Regularization{T} where T<:Real, Array{T, 1} where T<:Real, Any, RipQP.MatrixTools{T} where T<:Real, Any, Int64, Any, Any, Any, Any, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e0887260)[Core.MethodMatch(spec_types=Tuple{Type{RipQP.PreallocatedDataK2Krylov{T, S, M, MT, Pr, Ksol} where Ksol where Pr<:(RipQP.PreconditionerData{T, S} where S where T<:Real) where MT<:Union{Int64, RipQP.MatrixTools{T}} where M where S where T}, Pr, S, S, Bool, Bool, RipQP.Regularization{T}, Array{T, 1}, M, MT, Ksol, Int64, Real, Real, Real, Real, Int64} where Ksol<:(Krylov.KrylovWorkspace{T, FC, S} where S where FC where T) where Pr<:(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) where MT<: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, sparams=svec(T<:Real, S, 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}, MT<:Union{Int64, RipQP.MatrixTools{T<:Real}}, Pr<:(RipQP.PreconditionerData{T, S} where S where T<:Real), Ksol<:(Krylov.KrylovWorkspace{T, FC, S} where S where FC where T)), method=(::Type{RipQP.PreallocatedDataK2Krylov{T, S, M, MT, Pr, Ksol} where Ksol where Pr where MT where M where S where T})(Pr, S, S, Bool, Bool, RipQP.Regularization{T}, Array{T, 1}, M, MT, Ksol, Int64, T, T, T, T, Int64) where {T<:Real, S, M<:Union{AbstractArray{T, 2}, LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer}, MT<:Union{Int64, RipQP.MatrixTools{T}}, Pr<:(RipQP.PreconditionerData{T, S} where S where T<:Real), Ksol<:(Krylov.KrylovWorkspace{T, FC, S} where S where FC where T)}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{ft} where ft<:Number, Real}, limit=3), nothing, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.merge_fallback), NamedTuple{(:ap,), var"#s185"} where var"#s185"<:Tuple{RipQP.RipQPDoubleParameters{Float64, RipQP.K2LDLParams{Float64, RipQP.LDLFact}, _A, RipQP.PC, RipQP.PC} where _A<:RipQP.SolverParams{Float64}}, NamedTuple{(:history, :scaling, :display, :mode), Tuple{Bool, Bool, Bool, Symbol}}, Tuple{Symbol}, NTuple{4, Symbol}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bb4e6000)[Core.MethodMatch(spec_types=Tuple{typeof(Base.merge_fallback), NamedTuple{(:ap,), var"#s185"} where var"#s185"<:Tuple{RipQP.RipQPDoubleParameters{Float64, RipQP.K2LDLParams{Float64, RipQP.LDLFact}, _A, RipQP.PC, RipQP.PC} where _A<:RipQP.SolverParams{Float64}}, NamedTuple{(:history, :scaling, :display, :mode), Tuple{Bool, Bool, Bool, Symbol}}, Tuple{Symbol}, NTuple{4, 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=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001ae5, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.dotgetproperty), SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ea994e20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.dotgetproperty), SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T<:Real, Symbol}, sparams=svec(), method=dotgetproperty(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000002a2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcast_unalias), Base.SubArray{Float64, 1, Array{Float64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Array{_A, 1} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632eb102380)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcast_unalias), Base.SubArray{Float64, 1, Array{Float64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Array{_A, 1} where _A}, sparams=svec(), method=broadcast_unalias(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a0b, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{NLPModels.DimensionError}, String, Int64, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632cd98bd20)[ Core.MethodMatch(spec_types=Tuple{Type{NLPModels.DimensionError}, String, Int64, Int64}, sparams=svec(), method=(::Type{NLPModels.DimensionError})(Union{String, Symbol}, Int64, Int64), fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{NLPModels.DimensionError}, String, Int64, Any}, sparams=svec(), method=(::Type{NLPModels.DimensionError})(Any, Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009849, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._broadcast_getindex_evalf), typeof(Base.sqrt), Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b7481c20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._broadcast_getindex_evalf), typeof(Base.sqrt), Real}, sparams=svec(typeof(Base.sqrt), 1), method=_broadcast_getindex_evalf(Tf, Vararg{Any, N}) where {Tf, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000049e2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.SubArray{T, 1, P, I, false} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where T, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ad6f9da0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.SubArray{T, 1, P, I, false} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where T, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000029f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.__cat_offset1!), Array{_A, 1} where _A, Tuple{Int64}, 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, 0x7632cade71e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.__cat_offset1!), Array{_A, 1} where _A, Tuple{Int64}, Tuple{Bool}, Tuple{Int64}, Array{Ti, 1} where Ti<:Integer}, sparams=svec(), method=__cat_offset1!(Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000013f7, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.throw_boundserror), Base.Broadcast.Broadcasted{Nothing, var"#s185", typeof(Base.identity), var"#s185"} where var"#s185"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)} where var"#s185"<:Tuple, Tuple{Integer}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632abb38140)[Core.MethodMatch(spec_types=Tuple{typeof(Base.throw_boundserror), Base.Broadcast.Broadcasted{Nothing, var"#s185", typeof(Base.identity), var"#s185"} where var"#s185"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)} where var"#s185"<:Tuple, Tuple{Integer}}, sparams=svec(), method=throw_boundserror(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000032d, 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"#s185"} where var"#s185"<: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, 0x7632eada3c00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(LinearOperators.storage_type), var"#s185"} where var"#s185"<: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=0x000000000000029f, 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"#s185"} where var"#s185"<:Tuple{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, 0x7632b6d7f840)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.real), var"#s185"} where var"#s185"<:Tuple{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=0x000000000000029f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._tuple_error), Type{var"#s181"} where var"#s181"<:Tuple{Base.RefValue{typeof(SparseMatricesCOO.replace_if_minusinf)}, AbstractArray{T, N} where N where T, Float64}, Tuple{Base.RefValue{typeof(SparseMatricesCOO.replace_if_minusinf)}, AbstractArray{T, N} where N where T, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e09e4de0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._tuple_error), Type{var"#s181"} where var"#s181"<:Tuple{Base.RefValue{typeof(SparseMatricesCOO.replace_if_minusinf)}, AbstractArray{T, N} where N where T, Float64}, Tuple{Base.RefValue{typeof(SparseMatricesCOO.replace_if_minusinf)}, AbstractArray{T, N} where N where T, Float64}}, sparams=svec(), method=_tuple_error(Type, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000394, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.merge), NamedTuple{(:show_time,), Tuple{Bool}}, 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, 0x7632bac77660)[Core.MethodMatch(spec_types=Tuple{typeof(Base.merge), NamedTuple{(:show_time,), Tuple{Bool}}, 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"#s185", var"#s184", var"#s183", var"#s182"} where var"#s182"<:(NamedTuple{names, T} where T<:Tuple where names) where var"#s183" where var"#s184" where var"#s185"), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001aed, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), Any, typeof(Base.:(+)), AbstractArray{Float64, 1}, Any}, limit=3), nothing, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), 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}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ecc16e20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), 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}, sparams=svec(), method=size(LinearOperators.AbstractLinearOperator{T} where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{names, T} where T<:Tuple where names, Any, Integer, SolverTest.var"#f#98", Int64, ADNLPModels.var"#3#4"}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IndexStyle}, Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), var"#s185"}} where var"#s185"<: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}(4, 0x7632db431260)[ Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), var"#s185"}} where var"#s185"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}}, sparams=svec(), method=(::Type{Base.IndexStyle})(Type{var"#s683"} where var"#s683"<:(Base.Broadcast.Broadcasted{var"#s682", var"#s681", F, Args} where Args<:Tuple where F where var"#s681"<:Tuple{Any} where var"#s682")), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000492c, 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!##0#jac_structure!##1"{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, 0x7632ec6c1580)[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!##0#jac_structure!##1"{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=0x0000000000000c51, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unsafe_convert), Type{Ptr{Int32}}, GenericMemoryRef{:not_atomic, Int32, Core.AddrSpace{Core}(0x00)}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632eae2b200)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_convert), Type{Ptr{Int32}}, GenericMemoryRef{:not_atomic, Int32, Core.AddrSpace{Core}(0x00)}}, sparams=svec(Int32), method=unsafe_convert(Type{Ptr{T}}, GenericMemoryRef{isatomic, T, addrspace} where addrspace where T where isatomic) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000cb2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Pair{Symbol, 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, 0x7632ad8142e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Pair{Symbol, Array{QuadraticModels.PresolveOperation{T, _A}, 1}} where _A where T<:Real, Int64, Int64}, sparams=svec(), method=indexed_iterate(Pair{A, B} where B where A, Int64, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000816, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{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 where S where T}, QuadraticModels.AbstractQuadraticModel{T0, S0} where S0<:AbstractArray{T0, 1} where T0<:Real, RipQP.QM_IntData, RipQP.InputConfig{I} where I<:Integer, RipQP.InputTol{T0, Int64} where T0<:Real, RipQP.ScaleDataQP{T, S} where S where T<:Real, RipQP.StartingPointData{T, S} where S where T<:Real, RipQP.StopCrit{Float64}, RipQP.Counters, Bool, RipQP.QM_FloatData{T, S, M1, M2} where M2 where M1 where S where T<:Real, RipQP.Tolerances{T} where T<:Real, RipQP.QM_FloatData{T, S, M1, M2} where M2 where M1 where S where T<:Real, RipQP.Tolerances{T} where T<:Real, RipQP.QM_FloatData{T, S, M1, M2} where M2 where M1 where S where T<:Real, RipQP.Tolerances{T} where T<:Real, Union{RipQP.PreallocatedFloatData{T, _A, _B, _C, _D} where _D<:RipQP.PreallocatedData{T, _A} where _C<:RipQP.DescentDirectionAllocs{T, _A} where _B<:RipQP.AbstractResiduals{T, _A} where _A, RipQP.PreallocatedFloatData{T, S, _B, _C, _D} where _D<:RipQP.PreallocatedData{T, S} where _C<:RipQP.DescentDirectionAllocs{T, S} where _B<:RipQP.AbstractResiduals{T, S} where S} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ba2d0280)[Core.MethodMatch(spec_types=Tuple{Type{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 where S where T}, QMType, RipQP.QM_IntData, RipQP.InputConfig{Int64}, RipQP.InputTol{T, Int64}, Sd, RipQP.StartingPointData{T1, S1}, RipQP.StopCrit{Float64}, RipQP.Counters, Bool, QMfd1, RipQP.Tolerances{T1}, QMfd2, RipQP.Tolerances{T2}, QMfd3, RipQP.Tolerances{T}, Pfd} where Pfd<:(RipQP.PreallocatedFloatData{T1, S1, _B, _C, _D} where _D<:RipQP.PreallocatedData{T1, S1} where _C<:RipQP.DescentDirectionAllocs{T1, S1} where _B<:RipQP.AbstractResiduals{T1, S1}) where QMfd3<:(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 QMfd2<:(RipQP.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 QMfd1<:(RipQP.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 Sd<:RipQP.ScaleDataQP{T, S} where QMType<:QuadraticModels.AbstractQuadraticModel{T, S} where S<:AbstractArray{T, 1} where T<:Real, sparams=svec(T<:Real, S<:AbstractArray{T<:Real, 1}, Int64, QMType<:QMType<:QuadraticModels.AbstractQuadraticModel{T<:Real, S<:AbstractArray{T<:Real, 1}}, Sd<:Sd<:RipQP.ScaleDataQP{T<:Real, S<:AbstractArray{T<:Real, 1}}, Float64, T1<:Real, S1, QMfd1<:QMfd1<:(RipQP.QM_FloatData{T1<:Real, S1, M1, M2} where M2<:Union{AbstractArray{T1<:Real, 2}, LinearOperators.AbstractLinearOperator{T1<:Real}} where M1<:Union{AbstractArray{T1<:Real, 2}, LinearOperators.AbstractLinearOperator{T1<:Real}}), T2<:Real, QMfd2<:QMfd2<:(RipQP.QM_FloatData{T2<:Real, S, M1, M2} where M2<:Union{AbstractArray{T2<:Real, 2}, LinearOperators.AbstractLinearOperator{T2<:Real}} where M1<:Union{AbstractArray{T2<:Real, 2}, LinearOperators.AbstractLinearOperator{T2<:Real}} where S), QMfd3<:QMfd3<:(RipQP.QM_FloatData{T<:Real, S<:AbstractArray{T<:Real, 1}, M1, M2} where M2<:Union{AbstractArray{T<:Real, 2}, LinearOperators.AbstractLinearOperator{T<:Real}} where M1<:Union{AbstractArray{T<:Real, 2}, LinearOperators.AbstractLinearOperator{T<:Real}}), Pfd<:Pfd<:(RipQP.PreallocatedFloatData{T1<:Real, S1, _B, _C, _D} where _D<:RipQP.PreallocatedData{T1<:Real, S1} where _C<:RipQP.DescentDirectionAllocs{T1<:Real, S1} where _B<:RipQP.AbstractResiduals{T1<:Real, S1})), method=(::Type{RipQP.RipQPTripleSolver{T, S, I, QMType, Sd, Tsc, T1, S1, QMfd1, T2, QMfd2, QMfd3, Pfd} where Pfd where QMfd3 where QMfd2 where T2 where QMfd1 where S1 where T1 where Tsc where Sd where QMType where I where S where T})(QMType, RipQP.QM_IntData, RipQP.InputConfig{I}, RipQP.InputTol{T, I}, Sd, RipQP.StartingPointData{T1, S1}, RipQP.StopCrit{Tsc}, RipQP.Counters, Bool, QMfd1, RipQP.Tolerances{T1}, QMfd2, RipQP.Tolerances{T2}, QMfd3, RipQP.Tolerances{T}, Pfd) where {T, S, I, QMType<:QuadraticModels.AbstractQuadraticModel{T, S}, Sd<:RipQP.ScaleData{T, S}, Tsc<:Real, T1, S1, 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}}), T2, 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), 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}}), 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})}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, 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.identity), Tuple{Array{Int64, 1}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e18c5cc0)[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.identity), Tuple{Array{Int64, 1}}}}, sparams=svec(Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), Tuple{Array{Int64, 1}}), method=convert(Type{Base.Broadcast.Broadcasted{NewStyle, Axes, F, Args} where Args<:Tuple where F where Axes}, Base.Broadcast.Broadcasted{var"#s683", Axes, F, Args} where var"#s683") where {NewStyle, Axes, F, Args}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004913, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{NamedTuple{(:S,), T} where T<:Tuple}, Tuple{Type}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ca0bafc0)[Core.MethodMatch(spec_types=Tuple{Type{NamedTuple{(:S,), T} where T<:Tuple}, Tuple{Type}}, sparams=svec((:S,)), method=(::Type{NamedTuple{names, T} where T<:Tuple})(Tuple) where {names}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000019a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Dict{Symbol, String}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cafffa40)[Core.MethodMatch(spec_types=Tuple{Type{Base.Dict{Symbol, String}}}, sparams=svec(Symbol, String), method=(::Type{Base.Dict{K, V}})() where {K, V}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000358d, 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"#49#50", 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, 0x7632b93e7ca0)[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"#49#50", 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=0x000000000000984c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._broadcast_getindex_eltype), Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632de0f7980)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._broadcast_getindex_eltype), Real}, sparams=svec(), method=_broadcast_getindex_eltype(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000049eb, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{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, Any, Any, Array{ReverseDiff.AbstractInstruction, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b97c1ca0)[Core.MethodMatch(spec_types=Tuple{Type{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, Any, Any, Array{ReverseDiff.AbstractInstruction, 1}}, sparams=svec(V<:Real, D<:Real, 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))), method=(::Type{ReverseDiff.TrackedReal{V, D, O}})(Any, Any, Any) where {V, D, O}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009844, 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##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, 0x7632b58b8520)[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##12#PreconditionerData##13"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Nothing, Nothing, Int64, Int64, Int64}, sparams=svec(_A, Int64, F<:(RipQP.var"#PreconditionerData##12#PreconditionerData##13"{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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.to_indices), FillArrays.AbstractFill{T, 1, Axes} where Axes where T<:Real, Tuple{Any}, 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, 0x7632b715c9a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.to_indices), FillArrays.AbstractFill{T, 1, Axes} where Axes where T<:Real, Tuple{Any}, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}}, sparams=svec(), method=to_indices(Any, Any, Tuple{Any, Vararg}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000100c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.result_join), Base.Broadcast.DefaultArrayStyle{N} where N, Base.Broadcast.DefaultArrayStyle{1}, Base.Broadcast.DefaultArrayStyle{N} where N, Base.Broadcast.DefaultArrayStyle{N} where N}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632adc84ee0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.result_join), Base.Broadcast.DefaultArrayStyle{N} where N, Base.Broadcast.DefaultArrayStyle{1}, S, S} where S<:(Base.Broadcast.DefaultArrayStyle{N} where N), sparams=svec(S<:S<:(Base.Broadcast.DefaultArrayStyle{N} where N)), method=result_join(Any, Any, S, S) where {S<:Base.Broadcast.BroadcastStyle}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.result_join), Base.Broadcast.DefaultArrayStyle{N} where N, Base.Broadcast.DefaultArrayStyle{1}, Base.Broadcast.DefaultArrayStyle{N} where N, Base.Broadcast.DefaultArrayStyle{N} where N}, sparams=svec(S<:(Base.Broadcast.DefaultArrayStyle{N} where N), Base.Broadcast.DefaultArrayStyle{1}, U<:(Base.Broadcast.DefaultArrayStyle{N} where N), V<:(Base.Broadcast.DefaultArrayStyle{N} where N)), method=result_join(S, T, U, V) where {S, T, U, V}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004981, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.rem), UInt32, Type{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ecc370e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.rem), UInt32, Type{Int64}}, sparams=svec(), method=rem(UInt32, Type{Int64}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000b59, 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.UnitRange{Int64}, Tuple{Bool}, Tuple{Int64}}, Int64}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632db94f460)[ Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(<)), Tuple{Base.Broadcast.Extruded{Base.UnitRange{Int64}, Tuple{Bool}, Tuple{Int64}}, Int64}}}}, sparams=svec(), method=(::Type{Base.IndexStyle})(Type{var"#s683"} where var"#s683"<:(Base.Broadcast.Broadcasted{var"#s682", var"#s681", F, Args} where Args<:Tuple where F where var"#s681"<:Tuple{Any} where var"#s682")), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000492c, 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.:(/)), var"#s185"} where var"#s185"<: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, 0x7632e9d1e580)[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.:(/)), var"#s185"} where var"#s185"<:Tuple{FillArrays.Fill{Float64, 1, Tuple{Base.OneTo{Int64}}}, Array{T, 1} where T<:Number}}, sparams=svec(Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s185"<:Tuple{FillArrays.Fill{Float64, 1, Tuple{Base.OneTo{Int64}}}, Array{T, 1} where T<:Number}), method=convert(Type{Base.Broadcast.Broadcasted{NewStyle, Axes, F, Args} where Args<:Tuple where F where Axes}, Base.Broadcast.Broadcasted{var"#s683", Axes, F, Args} where var"#s683") where {NewStyle, Axes, F, Args}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004913, 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, 0x7632ded37b00)[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=0x0000000000000814, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), Tuple{Base.RefValue{typeof(Base.min)}, AbstractArray{T, 1} where T<:Real, AbstractArray{T, N} where N where T}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e0f7b580)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), Tuple{Base.RefValue{typeof(Base.min)}, AbstractArray{T, 1} where T<:Real, 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), Array{T, 1} where T<:(QuadraticModels.Row{T} where T<:Real)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ac3df640)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), Array{T, 1} where T<:(QuadraticModels.Row{T} where T<:Real)}, sparams=svec(), method=size(Array{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010c1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.cconvert), Type{Ptr{Int64}}, Array{Int64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cccd7600)[Core.MethodMatch(spec_types=Tuple{typeof(Base.cconvert), Type{Ptr{Int64}}, Array{Int64, 1}}, sparams=svec(), method=cconvert(Type{var"#s185"} where var"#s185"<:(Ptr{T} where T), Array{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000caa, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.compute_μ), Any, Any, AbstractArray{T, 1} where T<:Real, AbstractArray{T, 1} where T<:Real, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cda84920)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.compute_μ), Any, Any, AbstractArray{T, 1} where T<:Real, AbstractArray{T, 1} where T<:Real, Int64, Int64}, sparams=svec(), method=compute_μ(Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), Array{Ti, 1} where Ti<:Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cb00c5a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), Array{Ti, 1} where Ti<:Integer}, sparams=svec(), method=size(Array{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010c1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isconcretetype), Type{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cd83c560)[Core.MethodMatch(spec_types=Tuple{typeof(Base.isconcretetype), Type{Int64}}, sparams=svec(), method=isconcretetype(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000053d, 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}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632d9d6ba40)[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}}, 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=0x00000000000048f3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.to_index), Array{Float64, 1}, StaticArraysCore.StaticArray{var"#s25", Int64, N} where N where var"#s25"<:Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b66c5de0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.to_index), Array{Float64, 1}, StaticArraysCore.StaticArray{var"#s25", Int64, N} where N where var"#s25"<:Tuple}, sparams=svec(), method=to_index(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000ffb, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.convert), Type, Type{T} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632df5a8ea0)[ Core.MethodMatch(spec_types=Tuple{typeof(Core.convert), Type{Any}, Type{T} where T<:Real}, sparams=svec(), method=convert(Type{Any}, Any), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Core.convert), Type{T}, Type{T} where T<:Real} where T, sparams=svec(T), method=convert(Type{T}, T) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000044, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.iszero)}, var"#s185"} where var"#s185"<: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, 0x7632da26a360)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.iszero)}, var"#s185"} where var"#s185"<: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=0x000000000000491c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Tuple{FillArrays.Zeros{Float64, 1, Tuple{Base.OneTo{Int64}}}, Array{T, 1} where T<:Number}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e058a2e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Tuple{FillArrays.Zeros{Float64, 1, Tuple{Base.OneTo{Int64}}}, Array{T, 1} where T<:Number}, Int64}, sparams=svec(), method=getindex(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copy), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.real), var"#s185"} where var"#s185"<: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, 0x7632b7750200)[Core.MethodMatch(spec_types=Tuple{typeof(Base.copy), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.real), var"#s185"} where var"#s185"<:Tuple{Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64}}}, sparams=svec(), method=copy(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=0x0000000000004a07, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Iterators.Take{I} where I}, Base.IteratorsMD.CartesianIndices{N, R} where R<:Tuple{Vararg{Base.OrdinalRange{Int64, Int64}, N}} where N, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cb97dba0)[Core.MethodMatch(spec_types=Tuple{Type{Base.Iterators.Take{I} where I}, Base.IteratorsMD.CartesianIndices{N, R} where R<:Tuple{Vararg{Base.OrdinalRange{Int64, Int64}, N}} where N, Int64}, sparams=svec(I<:(Base.IteratorsMD.CartesianIndices{N, R} where R<:Tuple{Vararg{Base.OrdinalRange{Int64, Int64}, N}} where N)), method=(::Type{Base.Iterators.Take{I} where I})(I, Integer) where {I}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001966, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.RefValue{Ptr{SparseArrays.LibSuiteSparse.cholmod_factor_struct}}}, Ptr{SparseArrays.LibSuiteSparse.cholmod_factor_struct}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632aeedc660)[Core.MethodMatch(spec_types=Tuple{Type{Base.RefValue{Ptr{SparseArrays.LibSuiteSparse.cholmod_factor_struct}}}, Ptr{SparseArrays.LibSuiteSparse.cholmod_factor_struct}}, sparams=svec(Ptr{SparseArrays.LibSuiteSparse.cholmod_factor_struct}), method=(::Type{Base.RefValue{T}})(Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000cf4, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Base.Generator{Base.UnitRange{Int64}, F} where F<:(Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##0#__cat_offset1!##1"{Tuple{Int64}, Tuple{Bool}, Tuple{Int64}, Array{Ti, 1}}} where Ti<:Integer), Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cac1f800)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Base.Generator{Base.UnitRange{Int64}, F} where F<:(Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##0#__cat_offset1!##1"{Tuple{Int64}, Tuple{Bool}, Tuple{Int64}, Array{Ti, 1}}} where Ti<:Integer), Int64}, sparams=svec(), method=iterate(Base.Generator{I, F} where F where I, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000044b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._ntuple), Base.var"#__cat_offset1!##2#__cat_offset1!##3"{Tuple{Bool, Bool}, Tuple{Vararg{Int64, N}}, _A} where _A where N, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cac494c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._ntuple), Base.var"#__cat_offset1!##2#__cat_offset1!##3"{Tuple{Bool, Bool}, Tuple{Vararg{Int64, N}}, _A} where _A where N, Int64}, sparams=svec(F<:(Base.var"#__cat_offset1!##2#__cat_offset1!##3"{Tuple{Bool, Bool}, Tuple{Vararg{Int64, N}}, _A} where _A where N)), method=_ntuple(F, Int64) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001816, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Type{Bool}, Array{QuadraticModels.Row{Float64}, 1}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632db541620)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Type{Bool}, Array{QuadraticModels.Row{Float64}, 1}, Int64}, sparams=svec(), method=checkbounds(Type{Bool}, Union{Array{T, N} where N where T, Memory{T} where T}, Int64), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000035f, 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, Array{Float64, 1}}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dffe8ac0)[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, Array{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=0x00000000000048f4, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Tuple{String, String, String, String, Integer, String, typeof(DataType)}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cbb68700)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Tuple{String, String, String, String, Integer, String, typeof(DataType)}, Int64}, sparams=svec(), method=getindex(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Base.Iterators.Zip{Is} where Is<:Tuple{Base.OneTo{Int64}, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cb12db80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Base.Iterators.Zip{Is} where Is<:Tuple{Base.OneTo{Int64}, Any}}, sparams=svec(), method=iterate(Base.Iterators.Zip{Is} where Is<:Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001903, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._array_for), Type{Base.Rational{Int64}}, Base.HasShape{1}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ec209f00)[Core.MethodMatch(spec_types=Tuple{typeof(Base._array_for), Type{Base.Rational{Int64}}, Base.HasShape{1}, Tuple{Base.OneTo{Int64}}}, sparams=svec(Base.Rational{Int64}, 1), method=_array_for(Type{T}, Base.HasShape{N}, Any) where {T, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001125, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), Base.SubArray{_A, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{_A, 1} where _A) where _A, Base.Rational{Int64}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e99c6d60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Base.SubArray{_A, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{_A, 1} where _A) where _A, Base.Rational{Int64}, Int64}, sparams=svec(), method=setindex!(Base.SubArray{var"#s16", 1, P, I, true} where I where P where var"#s16", Any, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002ebb, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.abs), var"#s185"} where var"#s185"<: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, 0x7632dc0cb680)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.abs), var"#s185"} where var"#s185"<:Tuple{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.Broadcast._axes), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s185"} where var"#s185"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e1145aa0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s185"} where var"#s185"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, 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=0x000000000000491c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IndexStyle}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.max), Tuple{Base.Broadcast.Extruded{Array{Float64, 1}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{Array{Float64, 1}, Tuple{Bool}, Tuple{Int64}}, Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cd2e4240)[Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.max), Tuple{Base.Broadcast.Extruded{Array{Float64, 1}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{Array{Float64, 1}, Tuple{Bool}, Tuple{Int64}}, Int64}}}, 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=0x000000000000492b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.SubArray{Float64, 1, P, Tuple{Array{Int64, 1}}, false}} where P<:AbstractArray{Float64, 1}, AbstractArray{Float64, 1}, Tuple{Array{Int64, 1}}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632defeb0a0)[Core.MethodMatch(spec_types=Tuple{Type{Base.SubArray{Float64, 1, P, Tuple{Array{Int64, 1}}, false}} where P<:AbstractArray{Float64, 1}, AbstractArray{Float64, 1}, Tuple{Array{Int64, 1}}, Int64, Int64}, sparams=svec(Float64, 1, P<:AbstractArray{Float64, 1}, Tuple{Array{Int64, 1}}, 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=0x0000000000002e42, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), Array{T, 1} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b7d50e00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), Array{T, 1} where T}, sparams=svec(), method=combine_styles(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004972, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.deepcopy), QuadraticModels.AbstractQuadraticModel{Float64, S} where S}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cbb8e960)[Core.MethodMatch(spec_types=Tuple{typeof(Base.deepcopy), QuadraticModels.AbstractQuadraticModel{Float64, S} where S}, sparams=svec(), method=deepcopy(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000006629, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), Array{QuadraticModels.Col{T}, 1} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ade0c6e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), Array{QuadraticModels.Col{T}, 1} where T}, sparams=svec(), method=size(Array{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010c1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isempty), Tuple{String, Nothing, String, Int64, String, Nothing, String, Integer, String, String, String}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632e1282fa0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.isempty), Tuple{String, Nothing, String, Int64, String, Nothing, String, Integer, String, String, String}}, sparams=svec(), method=isempty(Tuple), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000074b, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), AbstractArray{T, 1} where T<:Real, Base.Broadcast.Broadcasted{var"#s683", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s683"}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b97e1de0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), AbstractArray{T, 1} where T<:Real, Base.Broadcast.Broadcasted{var"#s683", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s683"}, sparams=svec(), method=combine_styles(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004974, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Test.get_rng), Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632ead6a6a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Test.get_rng), Test.DefaultTestSet}, sparams=svec(), method=get_rng(Test.DefaultTestSet), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Test.get_rng), Test.AbstractTestSet}, sparams=svec(), method=get_rng(Test.AbstractTestSet), fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009817, 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}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ed525f20)[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}, Nothing}, 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=0x00000000000048f4, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Array{_A, 1} where _A, Type}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ae0008e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Array{_A, 1} where _A, Type}, sparams=svec(_A), method=similar(Array{T, 1}, Type) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010e9, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.datatype_pointerfree), Type{T} where T<:AbstractFloat}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632de3a0ea0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.datatype_pointerfree), Type{T} where T<:AbstractFloat}, sparams=svec(), method=datatype_pointerfree(typeof(DataType)), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000504, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.mightalias), FillArrays.Ones{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}(4, 0x7632e1b9ada0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.mightalias), FillArrays.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}, Array{T, 1} where T<:Number}, 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=0x0000000000001352, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), SparseMatricesCOO.SparseMatrixCOO{T, Ti} where Ti<:Integer where T<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cdfd7420)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), SparseMatricesCOO.SparseMatrixCOO{T, Ti} where Ti<:Integer where T<:Real, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000029f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseArrays.LibSuiteSparse.cholmod_l_allocate_dense), Int64, Int64, UInt64, Any, Ref{SparseArrays.LibSuiteSparse.cholmod_common_struct}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ae7057e0)[Core.MethodMatch(spec_types=Tuple{typeof(SparseArrays.LibSuiteSparse.cholmod_l_allocate_dense), Int64, Int64, UInt64, Any, Ref{SparseArrays.LibSuiteSparse.cholmod_common_struct}}, sparams=svec(), method=cholmod_l_allocate_dense(Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000980f, 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, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Nothing, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ae7d56e0)[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, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Nothing, Nothing}, sparams=svec(T, 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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Krylov.warm_start!), Krylov.KrylovWorkspace{T, FC, S} where S where FC where T, Any}, limit=3), nothing, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setproperty!), RipQP.StopCrit{Float64}, Symbol, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cb564100)[Core.MethodMatch(spec_types=Tuple{typeof(Base.setproperty!), RipQP.StopCrit{Float64}, Symbol, Any}, sparams=svec(), method=setproperty!(Any, Symbol, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000002a0, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IteratorsMD.CartesianIndices{N, R} where R<:Tuple{Vararg{Base.OrdinalRange{Int64, Int64}, N}} where N}, Any}, limit=3), nothing, #, #, 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, 0x7632da857f20)[ 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=0x0000000000004742, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Tuple{Tuple{Real}, Tuple{Int64}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ad0f8620)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Tuple{Tuple{Real}, Tuple{Int64}}, Int64}, sparams=svec(), method=getindex(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._broadcast_getindex_eltype), Array{R, 1} where R<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b8c98d60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._broadcast_getindex_eltype), Array{R, 1} where R<:Real}, sparams=svec(), method=_broadcast_getindex_eltype(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000049eb, 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, 0x7632eae77e80)[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=0x000000000000125e, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Unsigned}, Int128}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b97d5c40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Unsigned}, Int128}, sparams=svec(Unsigned), method=convert(Type{T}, Number) where {T<:Number}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000a6a, 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, 0x7632ab70efe0)[ 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=0x0000000000001263, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.cconvert), Type{Ptr{SparseArrays.LibSuiteSparse.cholmod_sparse_struct}}, SparseArrays.CHOLMOD.Sparse{Float32, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632db1a0920)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.cconvert), Type{Ptr{SparseArrays.LibSuiteSparse.cholmod_sparse_struct}}, SparseArrays.CHOLMOD.Sparse{Float32, Int64}}, sparams=svec(), method=cconvert(Type{var"#s66"} where var"#s66"<:(Ptr{T} where T), Any), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000003a4, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.axes), 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, 0x7632dbe2cfc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.axes), Base.SubArray{T, 1, P, I, L} where L where I where P where T}, sparams=svec(), method=axes(Base.SubArray{T, N, P, I, L} where L where I where P where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002eef, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.merge_fallback), NamedTuple{(:max_radius,), var"#s185"} where var"#s185"<:Tuple{Any}, 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, 0x7632ed17d1a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.merge_fallback), NamedTuple{(:max_radius,), var"#s185"} where var"#s185"<:Tuple{Any}, 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=0x0000000000001ae5, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(QuadraticModels.free_linear_singleton_columns!), QuadraticModels.QuadraticModelPresolveData{T, S} where S where T, 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, 0x7632b6aa71c0)[Core.MethodMatch(spec_types=Tuple{typeof(QuadraticModels.free_linear_singleton_columns!), QuadraticModels.QuadraticModelPresolveData{T, S}, Array{QuadraticModels.PresolveOperation{T, S}, 1}} where S where T<:Real, sparams=svec(T<:Real, S), method=free_linear_singleton_columns!(QuadraticModels.QuadraticModelPresolveData{T, S}, Array{QuadraticModels.PresolveOperation{T, S}, 1}) where {T, S}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000098de, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._tuple_error), Type{var"#s181"} where var"#s181"<:Tuple{AbstractArray{Float64, 1}}, Tuple{AbstractArray{Float64, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b928e320)[Core.MethodMatch(spec_types=Tuple{typeof(Base._tuple_error), Type{var"#s181"} where var"#s181"<:Tuple{AbstractArray{Float64, 1}}, Tuple{AbstractArray{Float64, 1}}}, sparams=svec(), method=_tuple_error(Type, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000394, 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)}, AbstractArray{Float64, 1}, Float64}}, UInt64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bba25f00)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.RefValue{typeof(SparseMatricesCOO.replace_if_minusinf)}, 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{typeof(Base.getindex), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s185"} where var"#s185"<: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, 0x7632e1894940)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s185"} where var"#s185"<: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=0x00000000000049c0, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.copyto_nonleaf!), Array{Float64, 1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.real), var"#s185"} where var"#s185"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64})}, Base.OneTo{Int64}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b6eeec40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.copyto_nonleaf!), Array{Float64, 1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.real), var"#s185"} where var"#s185"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64})}, 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=0x0000000000004a35, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), Any, LinearAlgebra.Adjoint{Float64, var"#s185"} where var"#s185"<:AbstractArray{Float64, 1}, Base.Broadcast.Broadcasted{Style, Nothing, typeof(SparseMatricesCOO.replace_if_minusinf), Args} where Args<:Tuple where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e1e1d860)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.Broadcast.BroadcastStyle, LinearAlgebra.Adjoint{Float64, var"#s185"} where var"#s185"<:AbstractArray{Float64, 1}, Base.Broadcast.Broadcasted{Style, Nothing, typeof(SparseMatricesCOO.replace_if_minusinf), Args} where Args<:Tuple where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, sparams=svec(), method=materialize!(Base.Broadcast.BroadcastStyle, Any, Base.Broadcast.Broadcasted{var"#s683", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s683"), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a03, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"##count#299", Int64, typeof(Base.count), typeof(Base.identity), 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, 0x7632ec8a39a0)[Core.MethodMatch(spec_types=Tuple{Base.var"##count#299", Int64, typeof(Base.count), typeof(Base.identity), 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"#count#299"(Any, typeof(Base.count), Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000339f, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.unconstrained), NLPModels.NLPModelMeta{T, V} where V<:AbstractArray{T, 1} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ec1b8a60)[Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.unconstrained), NLPModels.NLPModelMeta{T, V} where V<:AbstractArray{T, 1} where T}, sparams=svec(), method=unconstrained(NLPModels.AbstractNLPModelMeta{T, S} where S where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009849, 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, Base.UnitRange{Int64}, 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, 0x7632ebcc5fc0)[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, Base.UnitRange{Int64}, 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=0x0000000000009849, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{NamedTuple{(:hdr_override,), T} where T<:Tuple}, Tuple{Base.Dict{Symbol, String}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cadb5800)[Core.MethodMatch(spec_types=Tuple{Type{NamedTuple{(:hdr_override,), T} where T<:Tuple}, Tuple{Base.Dict{Symbol, String}}}, sparams=svec((:hdr_override,)), method=(::Type{NamedTuple{names, T} where T<:Tuple})(Tuple) where {names}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000019a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{ForwardDiff.Dual{_A, V, N} where N where V} where _A, Any, Tuple{Bool}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632d9c9e1e0)[ Core.MethodMatch(spec_types=Tuple{Type{ForwardDiff.Dual{_A, V, N} where N where V} where _A, Any, Tuple{Bool}}, sparams=svec(_A), method=(::Type{ForwardDiff.Dual{T, V, N} where N where V})(Any, Tuple) where {T}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009830, 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##0#PreconditionerData##1"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cd6eb0a0)[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##0#PreconditionerData##1"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real}, 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) where {T, I<:Integer}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.Generator{Tuple{StaticArraysCore.Dynamic, StaticArraysCore.Dynamic}, F} where F<:Function, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dc807f40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.Generator{Tuple{StaticArraysCore.Dynamic, StaticArraysCore.Dynamic}, F} where F<:Function, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000029f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setproperty!), Krylov.CgWorkspace{T, T, S} where S<:AbstractArray{T, 1} where T<:AbstractFloat, Symbol, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ad3ddb80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.setproperty!), Krylov.CgWorkspace{T, T, S} where S<:AbstractArray{T, 1} where T<:AbstractFloat, Symbol, Any}, sparams=svec(), method=setproperty!(Any, Symbol, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000002a0, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eltype), Array{Ti, 1} where Ti<:Integer}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cb281620)[Core.MethodMatch(spec_types=Tuple{typeof(Base.eltype), Array{Ti, 1} where Ti<:Integer}, sparams=svec(), method=eltype(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000127a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"##_minimum#752", Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), 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), Base.Colon}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dfd18640)[Core.MethodMatch(spec_types=Tuple{Base.var"##_minimum#752", Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), 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), Base.Colon}, sparams=svec(), method=var"#_minimum#752"(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._minimum), Any, Base.Colon), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000005b16, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), QuadraticModels.PresolvedQuadraticModel{Float64, Array{Float64, 1}, M1, M2} where M2 where M1, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b9443ba0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), QuadraticModels.PresolvedQuadraticModel{Float64, Array{Float64, 1}, M1, M2} where M2 where M1, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000029f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), AbstractArray{Float64, 2}}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.preprocess_args), Nothing, Tuple{Array{Ti, 1} where Ti<:Integer, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b7165440)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.preprocess_args), Nothing, Tuple{Array{Ti, 1} where Ti<:Integer, Int64}}, sparams=svec(), method=preprocess_args(Any, Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a11, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:fixed_vars_only,), Tuple{Bool}}, typeof(QuadraticModels.presolve), QuadraticModels.QuadraticModel{T, _A, _B, _C} where _C where _B where _A where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cab82280)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:fixed_vars_only,), Tuple{Bool}}, typeof(QuadraticModels.presolve), QuadraticModels.QuadraticModel{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(T<:Real, S, M1<:(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv), M2<:(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv)), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(QuadraticModels.presolve), QuadraticModels.QuadraticModel{T, S, M1, M2}) where {T<:Real, S, M1<:(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv), M2<:(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv)}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000098de, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isempty), Tuple{String, Type, String, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632bbb70c60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.isempty), Tuple{String, Type, String, Any}}, sparams=svec(), method=isempty(Tuple), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000074b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.structdiff), NamedTuple{(:x0,), var"#s185"} where var"#s185"<:Tuple{Any}, Type{NamedTuple{(:backend, :matrix_free, :show_time, :gradient_backend, :hprod_backend, :jprod_backend, :jtprod_backend, :jacobian_backend, :hessian_backend, :ghjvprod_backend), T} where T<:Tuple}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dc074be0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.structdiff), NamedTuple{(:x0,), var"#s185"} where var"#s185"<:Tuple{Any}, Type{NamedTuple{(:backend, :matrix_free, :show_time, :gradient_backend, :hprod_backend, :jprod_backend, :jtprod_backend, :jacobian_backend, :hessian_backend, :ghjvprod_backend), T} where T<:Tuple}}, sparams=svec((:x0,), (:backend, :matrix_free, :show_time, :gradient_backend, :hprod_backend, :jprod_backend, :jtprod_backend, :jacobian_backend, :hessian_backend, :ghjvprod_backend)), method=structdiff(NamedTuple{an, T} where T<:Tuple, Union{Type{NamedTuple{bn, T} where T<:Tuple}, NamedTuple{bn, T} where T<:Tuple}) where {an, bn}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001b06, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Iterators._zip_iterate_some), Tuple{Any}, Tuple{Tuple{}}, Tuple{Any}, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632cc1338a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators._zip_iterate_some), Tuple{Any}, Tuple{Tuple{}}, 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{}}, 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=0x0000000000001909, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{T} where Float64<:T<:Real, Float64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e0b773e0)[Core.MethodMatch(spec_types=Tuple{Type{T} where Float64<:T<:Real, Float64}, sparams=svec(Float64<:T<:Real), method=(::Type{T})(T) where {T<:Number}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000235, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.keys), NamedTuple{(:ϵ, :max_iter), var"#s185"} where var"#s185"<:Tuple{Any, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b66d9b40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.keys), NamedTuple{(:ϵ, :max_iter), var"#s185"} where var"#s185"<:Tuple{Any, Int64}}, sparams=svec((:ϵ, :max_iter)), method=keys(NamedTuple{names, T} where T<:Tuple) where {names}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001af2, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.structdiff), NamedTuple{(:lvar, :uvar, :x0), var"#s185"} where var"#s185"<:Tuple{Any, Any, Array{Float64, 1}}, Type{NamedTuple{(:Arows, :Acols, :Avals, :lcon, :ucon, :lvar, :uvar, :c0, :sortcols), T} where T<:Tuple}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cd4f0e20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.structdiff), NamedTuple{(:lvar, :uvar, :x0), var"#s185"} where var"#s185"<:Tuple{Any, Any, Array{Float64, 1}}, Type{NamedTuple{(:Arows, :Acols, :Avals, :lcon, :ucon, :lvar, :uvar, :c0, :sortcols), T} where T<:Tuple}}, sparams=svec((:lvar, :uvar, :x0), (:Arows, :Acols, :Avals, :lcon, :ucon, :lvar, :uvar, :c0, :sortcols)), method=structdiff(NamedTuple{an, T} where T<:Tuple, Union{Type{NamedTuple{bn, T} where T<:Tuple}, NamedTuple{bn, T} where T<:Tuple}) where {an, bn}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001b06, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.result_style), ReverseDiff.TrackedStyle, Base.Broadcast.BroadcastStyle}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632cd429460)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.result_style), ReverseDiff.TrackedStyle, ReverseDiff.TrackedStyle}, sparams=svec(ReverseDiff.TrackedStyle), method=result_style(S, S) where {S<:Base.Broadcast.BroadcastStyle}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.result_style), ReverseDiff.TrackedStyle, Base.Broadcast.BroadcastStyle}, sparams=svec(), method=result_style(Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000497a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#cvt1#convert##0"{var"#s181", var"#s185"} where var"#s185"<:Tuple{Base.RefValue{typeof(Base.:(/))}, AbstractArray{T, N} where N where T, Array{T, N} where N where T} where var"#s181"<: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, 0x7632dbbf40e0)[Core.MethodMatch(spec_types=Tuple{Base.var"#cvt1#convert##0"{var"#s181", var"#s185"} where var"#s185"<:Tuple{Base.RefValue{typeof(Base.:(/))}, AbstractArray{T, N} where N where T, Array{T, N} where N where T} where var"#s181"<:Tuple{Base.RefValue{typeof(Base.:(/))}, AbstractArray{T, N} where N where T, Array{T, N} where N where T}, Int64}, sparams=svec(var"#s181"<: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=0x0000000000000398, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._setindex!), Base.Dict{K, Any} where K, Nothing, Any, Int64, UInt8}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ad6f2200)[Core.MethodMatch(spec_types=Tuple{typeof(Base._setindex!), Base.Dict{K, Any} where K, Nothing, 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=0x00000000000035b6, 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, _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}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ca78bc60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.haslength), 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}}}, sparams=svec(), method=haslength(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000046d, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._deleteend!), Array{R, 1} where R, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632eab04ce0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._deleteend!), Array{R, 1} where R, Int64}, sparams=svec(), method=_deleteend!(Array{T, 1} where T, Integer), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001165, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.jacobian), Any, Array{Float64, 1}, ForwardDiff.JacobianConfig{T, Float64, _A, Array{ForwardDiff.Dual{T, Float64, _A}, 1}} where _A where T<:(ForwardDiff.Tag{_A, Float64} where _A) where _A where T<:(ForwardDiff.Tag{_A, Float64} where _A)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ca5679a0)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.jacobian), Any, Array{Float64, 1}, ForwardDiff.JacobianConfig{T, Float64, _A, Array{ForwardDiff.Dual{T, Float64, _A}, 1}} where _A where T<:(ForwardDiff.Tag{_A, Float64} where _A) where _A where T<:(ForwardDiff.Tag{_A, Float64} where _A)}, sparams=svec(F, T<:(ForwardDiff.Tag{_A, Float64} where _A)), method=jacobian(F, AbstractArray{T, N} where N where T, ForwardDiff.JacobianConfig{T, V, N, D} where D where N where V) where {F, T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009830, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.dataids), Base.SubArray{_A, _B, P, I, false} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ad777b40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.dataids), Base.SubArray{_A, _B, P, I, false} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A}, sparams=svec(), method=dataids(Base.SubArray{T, N, P, I, L} where L where I where P where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002e5c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), Any, Int64}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Tuple{String, String, String, String, Integer, String, typeof(DataType)}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cbb72140)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Tuple{String, String, String, String, Integer, String, typeof(DataType)}, Int64}, sparams=svec(), method=iterate(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006a3, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.tail), Tuple{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, 0x7632eab80c20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.tail), Tuple{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=tail(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000037d, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.solver!), Any, 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.DescentDirectionAllocsPC{Float64, S} where S, 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.Counters, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632caa1dfc0)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.solver!), AbstractArray{Float64, 1}, 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.DescentDirectionAllocsPC{Float64, S} where S, 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.Counters, Symbol}, sparams=svec(Float64), method=solver!(AbstractArray{T, 1}, 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.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=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_type), Type{Base.Rational{Int64}}, Type{Base.Rational{Int64}}, Type{Base.Rational{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632eab4dfe0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_type), Type{Base.Rational{Int64}}, Type{Base.Rational{Int64}}, Type{Base.Rational{Int64}}}, sparams=svec(), method=promote_type(Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000061b, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.haslength), Tuple{Pair{Symbol, Int64}, Vararg{Pair{A, B} where B where A}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632de5efa40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.haslength), Tuple{Pair{Symbol, Int64}, Vararg{Pair{A, B} where B where A}}}, sparams=svec(), method=haslength(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000046d, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.check_broadcast_shape), Tuple, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632d99e1d20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.check_broadcast_shape), Tuple{}, Tuple{Base.OneTo{Int64}}}, sparams=svec(), method=check_broadcast_shape(Tuple{}, Tuple), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.check_broadcast_shape), Tuple, Tuple{Base.OneTo{Int64}}}, sparams=svec(), method=check_broadcast_shape(Any, Tuple), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000049a4, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Type{Bool}, FillArrays.AbstractFill{T, 1, Axes} where Axes where Float64<:T<:Real, Array{Int64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632b8d66aa0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Type{Bool}, FillArrays.AbstractFill{T, 1, Axes} where Axes where Float64<:T<:Real, Array{Int64, 1}}, sparams=svec(), method=checkbounds(Type{Bool}, AbstractArray{T, N} where N where T, Any), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012ae, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.change_vector_eltype), typeof(DataType), Type{T} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632acfbce60)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.change_vector_eltype), Type{var"#s44"} where var"#s44"<:(Array{T, 1} where T), Type{T}} where T<:Real, sparams=svec(T<:Real), method=change_vector_eltype(Type{var"#s44"} where var"#s44"<:(Array{T, 1} where T), Type{T}) where {T}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s185"} where var"#s185"<:Tuple{Array{T, 2} where T}, Tuple{Array{T, 2} where T}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7632cddfd4e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Tuple{Array{T, 2} where T}}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, Tuple{Array{T, 2} where T}} where T<:Tuple{Array{T, 2} where T}, 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"#s185"} where var"#s185"<:Tuple{Array{T, 2} where T}, Tuple{Array{T, 2} where T}}, sparams=svec(1, var"#s185"<:Tuple{Array{T, 2} where T}), method=convert(Type{T}, Tuple{Vararg{Any, N}}) where {N, T<:Tuple}, fully_covers=true), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000399, max_world=0xffffffffffffffff), ambig=false), 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##4#PreconditionerData##5"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}, Nothing, Nothing, Int64, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cd611c20)[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##4#PreconditionerData##5"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}, Nothing, Nothing, Int64, Int64, Int64}, sparams=svec(T<:Real, Int64, F<:(RipQP.var"#PreconditionerData##4#PreconditionerData##5"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}), 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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.get_mat_QPData), Any, Any, Int64, Int64, RipQP.K2LDLParams{Float64, RipQP.LDLFact}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632b979b460)[ Core.MethodMatch(spec_types=Tuple{typeof(RipQP.get_mat_QPData), SparseMatricesCOO.SparseMatrixCOO{T, Int64}, SparseMatricesCOO.SparseMatrixCOO{T, Int64}, Int64, Int64, RipQP.K2LDLParams{Float64, RipQP.LDLFact}} 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.K2LDLParams{Float64, RipQP.LDLFact}}, 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=0x0000000000009906, 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{Int32}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e13be300)[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{Int32}, Tuple{Int64}}, sparams=svec(Int32, 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}}}, Ptr{T}, Tuple{Vararg{Int64, N}}) where {T, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000cb7, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.TwicePrecision{Float64}}, Tuple{Int64, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632baa06e40)[Core.MethodMatch(spec_types=Tuple{Type{Base.TwicePrecision{Float64}}, Tuple{Int64, Int64}}, sparams=svec(Float64), method=(::Type{Base.TwicePrecision{T}})(Tuple{Any, Any}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002f9d, 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.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}, Array{T, 1} where T<:Number}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e1120840)[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.Ones{Float64, 1, Tuple{Base.OneTo{Int64}}}, Array{T, 1} where T<:Number}, 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=0x00000000000048f4, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, var"#s185", typeof(Base.:(/)), var"#s185"} where var"#s185"<:Tuple{Base.SubArray{T, 1, P, I, L} where L where I where P where T, Array{T, 1} where T<:Number} where var"#s185"<:Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632d9b4d8a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, var"#s185", typeof(Base.:(/)), var"#s185"} where var"#s185"<:Tuple{Base.SubArray{T, 1, P, I, L} where L where I where P where T, Array{T, 1} where T<:Number} where var"#s185"<: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=0x0000000000004945, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s181", var"#s185"} where var"#s185"<:Tuple{Base.RefValue{typeof(Base.min)}, AbstractArray{T, 1} where T<:Real, AbstractArray{T, N} where N where T} where var"#s181"<:Tuple{Base.RefValue{typeof(Base.min)}, AbstractArray{T, 1} where T<:Real, AbstractArray{T, N} where N where T}, Base.Val{3}}, limit=5), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e0f59c40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s181", var"#s185"} where var"#s185"<:Tuple{Base.RefValue{typeof(Base.min)}, AbstractArray{T, 1} where T<:Real, AbstractArray{T, N} where N where T} where var"#s181"<:Tuple{Base.RefValue{typeof(Base.min)}, AbstractArray{T, 1} where T<:Real, AbstractArray{T, N} where N where T}, Base.Val{3}}, sparams=svec(), method=ntuple(Any, Base.Val{3}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000181c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Base.Generator{Base.UnitRange{Int64}, F} where F<:(QuadraticModels.var"#get_arows_acols##0#get_arows_acols##1"{_A, Array{Int64, 1}} where _A), Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ae0d67c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Base.Generator{Base.UnitRange{Int64}, F} where F<:(QuadraticModels.var"#get_arows_acols##0#get_arows_acols##1"{_A, Array{Int64, 1}} where _A), Int64}, sparams=svec(), method=iterate(Base.Generator{I, F} where F where I, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000044b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Type{Bool}, Array{ForwardDiff.Dual{Tag, T, 1}, 1} where Tag where T, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632dff1d520)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Type{Bool}, Array{ForwardDiff.Dual{Tag, T, 1}, 1} where Tag where T, Int64}, sparams=svec(), method=checkbounds(Type{Bool}, Union{Array{T, N} where N where T, Memory{T} where T}, Int64), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000035f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), RipQP.PreallocatedData{T, S} where S where T<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632badbf640)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), RipQP.PreallocatedData{T, S} where S where T<:Real, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000029f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.iszero)}, var"#s185"} where var"#s185"<:Tuple{Array{T, 2} where T}, typeof(DataType)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e058d360)[Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.iszero)}, var"#s185"} where var"#s185"<:Tuple{Array{T, 2} where T}, typeof(DataType)}, 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=0x0000000000004915, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s181", var"#s185"} where var"#s185"<:Tuple{Base.Broadcast.Broadcasted{var"#s185", Nothing, typeof(Base.sqrt), var"#s185"} where var"#s185"<:Tuple{AbstractArray{T, 1} where T<:Real} where var"#s185"<:Base.Broadcast.BroadcastStyle} where var"#s181"<:Tuple{Base.Broadcast.Broadcasted{var"#s185", Nothing, typeof(Base.sqrt), var"#s185"} where var"#s185"<:Tuple{AbstractArray{T, 1} where T<:Real} where var"#s185"<:Base.Broadcast.BroadcastStyle}, Base.Val{1}}, limit=5), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632de6b53a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s181", var"#s185"} where var"#s185"<:Tuple{Base.Broadcast.Broadcasted{var"#s185", Nothing, typeof(Base.sqrt), var"#s185"} where var"#s185"<:Tuple{AbstractArray{T, 1} where T<:Real} where var"#s185"<:Base.Broadcast.BroadcastStyle} where var"#s181"<:Tuple{Base.Broadcast.Broadcasted{var"#s185", Nothing, typeof(Base.sqrt), var"#s185"} where var"#s185"<:Tuple{AbstractArray{T, 1} where T<:Real} where var"#s185"<:Base.Broadcast.BroadcastStyle}, Base.Val{1}}, sparams=svec(), method=ntuple(Any, Base.Val{1}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000181a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.perturb_x!), AbstractArray{T, 1} where T<:Real, AbstractArray{T, 1} where T<:Real, AbstractArray{T, 1} where T<:Real, Any, Any, Any, Any, Any, Array{Int64, 1}, Array{Int64, 1}, Int64, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b7c02320)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.perturb_x!), AbstractArray{T, 1}, AbstractArray{T, 1}, AbstractArray{T, 1}, AbstractArray{T, 1}, AbstractArray{T, 1}, AbstractArray{T, 1}, AbstractArray{T, 1}, Real, Array{Int64, 1}, Array{Int64, 1}, Int64, Int64, Int64} where T<:Real, sparams=svec(T), method=perturb_x!(AbstractArray{T, 1}, AbstractArray{T, 1}, AbstractArray{T, 1}, AbstractArray{T, 1}, AbstractArray{T, 1}, AbstractArray{T, 1}, AbstractArray{T, 1}, T, Array{Int64, 1}, Array{Int64, 1}, Int64, Int64, Int64) where {T}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), 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, 0x7632de574480)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Tuple{Pair{Symbol, Int64}, Vararg{Pair{A, B} where B where A}}, Int64}, sparams=svec(), method=iterate(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006a3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), 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, 0x7632e1178300)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), Tuple{Base.RefValue{typeof(Base.:(<))}, 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{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, Any, Array{T, N} where N where T}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632eab91220)[ 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, Any, Array{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{Any, Base.RefValue{T} where T, Any, Array{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=0x00000000000048f3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.get), Base.IdDict{Any, Any}, QuadraticModels.QuadraticModel{T, S, M1, M2} where M2 where M1 where S where T, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cbcf1640)[Core.MethodMatch(spec_types=Tuple{typeof(Base.get), Base.IdDict{Any, Any}, QuadraticModels.QuadraticModel{T, S, M1, M2} where M2 where M1 where S 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=0x00000000000017e3, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, 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)}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632eb7f3160)[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)}}}, 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{Base.StepRangeLen{Float16, R, S, L} where L<:Integer where S where R}, Float64, Float64, Integer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bb1dba00)[Core.MethodMatch(spec_types=Tuple{Type{Base.StepRangeLen{Float16, R, S, L} where L<:Integer where S where R}, Float64, Float64, Integer, Int64}, sparams=svec(Float16, Float64, Float64), method=(::Type{Base.StepRangeLen{T, R, S, L} where L<:Integer where S where R})(R, S, Integer, Integer) where {T, R, S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000008da, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{SolverCore.GenericExecutionStats{Float64, Array{Float64, 1}, Array{Float64, 1}, QuadraticModels.PresolvedQuadraticModel{Float64, Array{Float64, 1}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}}}}, Bool, Symbol, Bool, Array{Float64, 1}, Bool, Float64, Bool, Float64, Bool, Float64, Bool, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool, Float64, Bool, 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, 0x7632deb116e0)[Core.MethodMatch(spec_types=Tuple{Type{SolverCore.GenericExecutionStats{Float64, Array{Float64, 1}, Array{Float64, 1}, QuadraticModels.PresolvedQuadraticModel{Float64, Array{Float64, 1}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}}}}, Bool, Symbol, Bool, Array{Float64, 1}, Bool, Float64, Bool, Float64, Bool, Float64, Bool, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool, Float64, Bool, Base.Dict{Symbol, QuadraticModels.PresolvedQuadraticModel{Float64, Array{Float64, 1}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}}}}, 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=0x0000000000009856, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), 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, 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}(4, 0x7632d9af1260)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), 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, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, Nothing, typeof(Base.identity), Tuple{Float64}}}, sparams=svec(), method=materialize!(Any, Base.Broadcast.Broadcasted{var"#s683", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s683"), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a02, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Base.Rational{Int64}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632eb8ba2e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Base.Rational{Int64}}, Int64}, sparams=svec(Base.Rational{Int64}), method=convert(Type{T}, Number) where {T<:Number}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000a6a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(*)), var"#s185"} where var"#s185"<: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, 0x7632ead15f20)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(*)), var"#s185"} where var"#s185"<:Tuple{Int64, 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{typeof(Base.copy), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(var"==")), var"#s185"} where var"#s185"<: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, 0x7632e9e0fd40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.copy), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(var"==")), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R, Array{R, 1} where R}}, sparams=svec(), method=copy(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=0x0000000000004a07, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), Tuple{Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cad1b240)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), Tuple{Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{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(SparseArrays.sparse), Array{Int64, 1}, Array{Int64, 1}, Array{T, 1} where T, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632dc819f20)[ Core.MethodMatch(spec_types=Tuple{typeof(SparseArrays.sparse), Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Int64, Int64}, sparams=svec(), method=sparse(Any, Any, AbstractArray{Bool, 1}, Any, Any), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(SparseArrays.sparse), Array{Int64, 1}, Array{Int64, 1}, Array{T, 1} where T, Int64, Int64}, sparams=svec(), method=sparse(Any, Any, AbstractArray{T, 1} where T, Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000980f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.map!), ForwardDiff.var"#extract_value!##0#extract_value!##1"{Nothing}, Any, AbstractArray{T, N} where N where T}, limit=3), nothing, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.length), AbstractArray{T, 1} where T<:AbstractFloat}, limit=3), nothing, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv<:Number, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b80f3880)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv<:Number, Int64}, sparams=svec(Tv<:Number, 2), method=size(AbstractArray{T, N}, Any) where {T, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000125c, 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##6#PreconditionerData##7"{var"#s185"} where var"#s185"<:RipQP.FactorizationData{Tlow} where Tlow<:Real, Nothing, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b6a23640)[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##6#PreconditionerData##7"{var"#s185"} where var"#s185"<:RipQP.FactorizationData{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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), AbstractArray{T, N} where N where T, Any, Any}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.check_parent_index_match), Array{_A, 1} where _A, Tuple{Base.UnitRange{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e14bf720)[Core.MethodMatch(spec_types=Tuple{typeof(Base.check_parent_index_match), Array{_A, 1} where _A, Tuple{Base.UnitRange{Int64}}}, sparams=svec(), method=check_parent_index_match(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002e47, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ReverseDiff.record!), Array{ReverseDiff.AbstractInstruction, 1}, Type{ReverseDiff.SpecialInstruction{F, I, O, C} where C where O where I where F}, typeof(Base.fill), Tuple{ReverseDiff.TrackedReal{V, D, O} where O where D<:Real where V<: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#281#23", NamedTuple{(), Tuple{}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b945c3c0)[Core.MethodMatch(spec_types=Tuple{typeof(ReverseDiff.record!), Array{ReverseDiff.AbstractInstruction, 1}, Type{ReverseDiff.SpecialInstruction{F, I, O, C} where C where O where I where F}, typeof(Base.fill), Tuple{ReverseDiff.TrackedReal{V, D, O} where O where D<:Real where V<: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#281#23", NamedTuple{(), Tuple{}}}}, sparams=svec(ReverseDiff.SpecialInstruction{F, I, O, C} where C where O where I where F), method=record!(Array{ReverseDiff.AbstractInstruction, 1}, Type{InstructionType}, Any...) where {InstructionType}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009844, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.show_delim_array), Base.GenericIOBuffer{Memory{UInt8}}, Array{R, 1} where R<:Real, String, String, Char, Bool, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b9a87fe0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.show_delim_array), Base.GenericIOBuffer{Memory{UInt8}}, Array{R, 1} where R<:Real, String, String, Char, Bool, Int64, Int64}, sparams=svec(), method=show_delim_array(IO, Union{Core.SimpleVector, AbstractArray{T, N} where N where T}, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000042ec, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.throw_boundserror), 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, 0x7632b8755100)[Core.MethodMatch(spec_types=Tuple{typeof(Base.throw_boundserror), Array{T, 1} where T<:Real, Tuple{Base.UnitRange{Int64}}}, sparams=svec(), method=throw_boundserror(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000032d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), Array{_A, 2} where _A, Any, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cbcaef20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Array{_A, 2} where _A, Any, Int64, Int64}, sparams=svec(_A), method=setindex!(Array{T, N} where N, Any, Int64, Int64, Int64...) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000114b, 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, 0x7632e9ad9be0)[ 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=0x0000000000004a9c, 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.real), var"#s185"} where var"#s185"<: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, 0x7632b6f72260)[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.real), var"#s185"} where var"#s185"<: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=0x0000000000004a33, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), AbstractArray{T, 1} where T, Base.Broadcast.Broadcasted{var"#s185", Nothing, typeof(RipQP.safe_boundary), var"#s185"} where var"#s185"<:Tuple{AbstractArray{var"#s682", 1} where var"#s682"} where var"#s185"<:Base.Broadcast.BroadcastStyle}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632baa39920)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), AbstractArray{T, 1} where T, Base.Broadcast.Broadcasted{var"#s185", Nothing, typeof(RipQP.safe_boundary), var"#s185"} where var"#s185"<:Tuple{AbstractArray{var"#s682", 1} where var"#s682"} where var"#s185"<:Base.Broadcast.BroadcastStyle}, sparams=svec(), method=materialize!(Any, Base.Broadcast.Broadcasted{var"#s683", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s683"), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a02, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), 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, 0x7632d9952000)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), 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=combine_styles(Any, Any, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004975, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(-)), Integer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(6, 0x7632cbe77360)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.:(-)), Base.GMP.BigInt, Int64}, sparams=svec(), method=-(Base.GMP.BigInt, Union{Int16, Int32, Int64, Int8}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.:(-)), Int64, Int64}, sparams=svec(Int64), method=-(T, T) where {T<:Union{Int128, Int16, Int32, Int64, Int8, UInt128, UInt16, UInt32, UInt64, UInt8}}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.:(-)), Integer, Int64}, sparams=svec(), method=-(Integer, Integer), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000006105, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.to_indices), Array{Float64, 1}, Tuple{Base.OneTo{Int64}}, 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=(2,), mem=Memory{Any}(4, 0x7632b65c3ae0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.to_indices), Array{Float64, 1}, Tuple{Base.OneTo{Int64}}, Tuple{Base.IteratorsMD.CartesianIndex{N}, Base.IteratorsMD.CartesianIndex{0}}} where N, sparams=svec(N), method=to_indices(Any, Any, Tuple{Base.IteratorsMD.CartesianIndex{N}, Vararg}) where {N}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.to_indices), Array{Float64, 1}, Tuple{Base.OneTo{Int64}}, 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=to_indices(Any, Any, Tuple{Any, Vararg}), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047eb, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._compute_eltype), Type{Tuple{Bool, Bool, Bool, Symbol}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e99de580)[Core.MethodMatch(spec_types=Tuple{typeof(Base._compute_eltype), Type{Tuple{Bool, Bool, Bool, Symbol}}}, sparams=svec(), method=_compute_eltype(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006d0, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), AbstractArray{T, 1} where T<:Real, Float64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632da8d1b00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), AbstractArray{T, 1} where T<:Real, Float64}, sparams=svec(), method=combine_styles(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004974, 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, 0x7632b8412d40)[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=0x000000000000037b, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.string), Type{F} where F<:FixedPointNumbers.Fixed{T, f} where f where T<:Signed, String, String, String, Int64, String, String, String, String, String, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ca9bbae0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.string), Type{F} where F<:FixedPointNumbers.Fixed{T, f} where f where T<:Signed, String, String, String, Int64, String, String, String, String, String, Int64}, sparams=svec(), method=string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003ea3, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.merge), NamedTuple{names, T} where T<:Tuple where names, NamedTuple{(:rng,), var"#s185"} where var"#s185"<:Tuple{Any}}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632e96744a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.merge), NamedTuple{(), T} where T<:Tuple, NamedTuple{(:rng,), var"#s185"} where var"#s185"<:Tuple{Any}}, sparams=svec(), method=merge(NamedTuple{(), T} where T<:Tuple, NamedTuple{names, T} where T<:Tuple where names), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.merge), NamedTuple{names, T} where T<:Tuple where names, NamedTuple{(:rng,), var"#s185"} where var"#s185"<:Tuple{Any}}, sparams=svec(names, (:rng,)), 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=0x0000000000001aec, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), AbstractArray{Float64, 1}, Int64, Int64}, limit=3), nothing, #, #, #, #, 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, 0x7632bb439ac0)[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=0x0000000000000299, 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}, AbstractArray{Float64, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632df2b1420)[Core.MethodMatch(spec_types=Tuple{typeof(Core._typeof_captured_variable), Tuple{Any, Base.RefValue{T} where T, 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.signature_type), QuadraticModels.var"#opPermutedMinusOnes##0#opPermutedMinusOnes##1"{Array{Int64, 1}}, Type{Tuple}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bbbb62e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.signature_type), QuadraticModels.var"#opPermutedMinusOnes##0#opPermutedMinusOnes##1"{Array{Int64, 1}}, Type{Tuple}}, sparams=svec(), method=signature_type(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000569, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s181"} where var"#s181"<:(AbstractArray{T, 1} where T<:Real), AbstractArray{T, 1} where T<:Real}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.jacobian), Any, Array{Float64, 1}, ForwardDiff.JacobianConfig{Nothing, Float64, _A, Array{ForwardDiff.Dual{Nothing, Float64, _A}, 1}} where _A where _A, Base.Val{true}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ca554820)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.jacobian), Any, Array{Float64, 1}, ForwardDiff.JacobianConfig{Nothing, Float64, _A, Array{ForwardDiff.Dual{Nothing, Float64, _A}, 1}} where _A where _A, Base.Val{true}}, sparams=svec(F, Nothing, true), method=jacobian(F, AbstractArray{T, N} where N where T, ForwardDiff.JacobianConfig{T, V, N, D} where D where N where V, Base.Val{CHK}) where {F, T, CHK}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009830, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.reduce_empty_iter), Base.MappingRF{typeof(Base.identity), typeof(Base.max)}, Array{T, 1} where T<:Real, Base.HasEltype}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b8877cc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.reduce_empty_iter), Base.MappingRF{typeof(Base.identity), typeof(Base.max)}, Array{T, 1} where T<:Real, Base.HasEltype}, sparams=svec(), method=reduce_empty_iter(Any, Any, Base.HasEltype), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003328, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Tuple{Vararg{Symbol}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ebde9dc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Tuple{Vararg{Symbol}}, Int64}, sparams=svec(), method=getindex(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.keys), NamedTuple{(:solution, :multipliers, :multipliers_L, :multipliers_U, :solver_specific), var"#s185"} where var"#s185"<:Tuple{Any, Any, Any, Any, Base.Dict{K, V} where V where K}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e00c51c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.keys), NamedTuple{(:solution, :multipliers, :multipliers_L, :multipliers_U, :solver_specific), var"#s185"} where var"#s185"<:Tuple{Any, Any, Any, Any, Base.Dict{K, V} where V where K}}, sparams=svec((:solution, :multipliers, :multipliers_L, :multipliers_U, :solver_specific)), method=keys(NamedTuple{names, T} where T<:Tuple) where {names}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001af2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.merge_types), Tuple{Vararg{Symbol}}, Type{NamedTuple{(:ap,), var"#s185"}} where var"#s185"<:Tuple{RipQP.RipQPDoubleParameters{Float64, RipQP.K2LDLParams{Float64, RipQP.LDLFact}, _A, RipQP.PC, RipQP.PC} where _A<:RipQP.SolverParams{Float64}}, Type{NamedTuple{(:history, :scaling, :display, :mode), Tuple{Bool, Bool, Bool, Symbol}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ca35a060)[Core.MethodMatch(spec_types=Tuple{typeof(Base.merge_types), Tuple{Vararg{Symbol}}, Type{NamedTuple{(:ap,), var"#s185"}} where var"#s185"<:Tuple{RipQP.RipQPDoubleParameters{Float64, RipQP.K2LDLParams{Float64, RipQP.LDLFact}, _A, RipQP.PC, RipQP.PC} where _A<:RipQP.SolverParams{Float64}}, Type{NamedTuple{(:history, :scaling, :display, :mode), Tuple{Bool, Bool, Bool, Symbol}}}}, sparams=svec(), method=merge_types(Tuple{Vararg{Symbol}}, Type{var"#s185"} where var"#s185"<:(NamedTuple{names, T} where T<:Tuple where names), Type{var"#s184"} where var"#s184"<:(NamedTuple{names, T} where T<:Tuple where names)), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001ae3, 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, 0x7632ec6305a0)[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=0x00000000000047ce, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{RipQP.IterData{T, S} where S where T<:Real}, Vararg{Any, 17}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ed0246a0)[Core.MethodMatch(spec_types=Tuple{Type{RipQP.IterData{T, S} where S where T<:Real}, Vararg{Any, 17}}, sparams=svec(), method=(::Type{RipQP.IterData{T, S} where S where T<:Real})(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=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), Tuple{AbstractArray{T, 1} where T<:Real, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dba63ba0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), Tuple{AbstractArray{T, 1} where T<:Real, 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._count), typeof(SparseArrays._isnotzero), Array{Tv, 2} where Tv<:Real, Base.Colon, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632b81837e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base._count), typeof(SparseArrays._isnotzero), Array{Tv, 2} where Tv<:Real, Base.Colon, Int64}, sparams=svec(), method=_count(Any, Union{Base.AbstractBroadcasted, AbstractArray{T, N} where N where T}, Base.Colon, Any), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000005acf, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), FillArrays.Zeros{Float64, 1, Tuple{Base.OneTo{Int64}}}, FillArrays.Zeros{_A, 1, Tuple{Base.OneTo{Int64}}} where _A}, limit=1), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632da9c6620)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.copyto!), FillArrays.Zeros{Float64, 1, Tuple{Base.OneTo{Int64}}}, FillArrays.Zeros{_A, 1, Tuple{Base.OneTo{Int64}}} where _A}, sparams=svec(), method=copyto!(AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012e4, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Any, Type, Vararg{Type}}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseArrays.CHOLMOD.xdtyp), Type{Tnew} where Tnew<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632af088ec0)[Core.MethodMatch(spec_types=Tuple{typeof(SparseArrays.CHOLMOD.xdtyp), Type{Tnew} where Tnew<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}}, sparams=svec(Tnew<:Union{Base.Complex{Float32}, Base.Complex{Float64}, Float32, Float64}), method=xdtyp(Type{T}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000980f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{RipQP.InputTol{T, I}} where I<:Integer where T<:Real, Int64, Int64, Int64, Real, Real, Real, Real, Real, Real, Real, Real, Real, Real, Real, Real, Float64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cb730dc0)[Core.MethodMatch(spec_types=Tuple{Type{RipQP.InputTol{T, I}} where I<:Integer where T<:Real, Int64, Int64, Int64, Real, Real, Real, Real, Real, Real, Real, Real, Real, Real, Real, Real, Float64}, sparams=svec(), method=(::Type{RipQP.InputTol{T<:Real, I<:Integer}})(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=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.inferencebarrier), Type{Array{Tv, 1}} where Tv<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b8eef9c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.inferencebarrier), Type{Array{Tv, 1}} where Tv<:Real}, sparams=svec(), method=inferencebarrier(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000003e3, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unaliascopy), Array{T, 1} where T<:Number}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dabbc200)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unaliascopy), Array{T, 1} where T<:Number}, sparams=svec(), method=unaliascopy(Array{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000134b, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{AbstractArray{T, 1} where T<:Real, AbstractArray{T, 1} where T<:Real}}, UInt64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e1a8a400)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{AbstractArray{T, 1} where T<:Real, 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{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, 0x7632e19e0120)[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=0x00000000000048f3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.throw_boundserror), Array{QuadraticModels.Row{T}, 1} where T<:Real, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b61c6000)[Core.MethodMatch(spec_types=Tuple{typeof(Base.throw_boundserror), Array{QuadraticModels.Row{T}, 1} where T<:Real, Tuple{Int64}}, sparams=svec(), method=throw_boundserror(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000032d, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s181"} where var"#s181"<:Base.Broadcast.BroadcastStyle, Base.Broadcast.BroadcastStyle}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632e0167b20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Base.Broadcast.BroadcastStyle}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, Base.Broadcast.BroadcastStyle} where T<:Base.Broadcast.BroadcastStyle, sparams=svec(T), method=convert(Type{T}, T) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000036c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{ForwardDiff.Partials{1, _A}} where _A, Tuple{Bool}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ed05bdc0)[Core.MethodMatch(spec_types=Tuple{Type{ForwardDiff.Partials{1, _A}} where _A, Tuple{Bool}}, sparams=svec(), method=(::Type{ForwardDiff.Partials{N, V}})(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009830, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), 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, 0x7632b8d24c80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), FillArrays.AbstractZeros{T, 1, Axes} where Axes where T<:Real}, sparams=svec(), method=size(FillArrays.AbstractZeros{T, N, Axes} where Axes where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000981b, 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, 0x7632b90364a0)[ 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=0x0000000000001073, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._setindex!), Base.IndexCartesian, SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv<:Real, Any, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e08cd0c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._setindex!), Base.IndexCartesian, SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv<:Real, Any, Int64, Int64}, sparams=svec(Tv<:Real, 2), method=_setindex!(Base.IndexCartesian, AbstractArray{T, N}, Any, Vararg{Int64, N}) where {T, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001342, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isbitstype), Type{QuadraticModels.PresolveOperation{Float64, Array{Float64, 1}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cd57f780)[Core.MethodMatch(spec_types=Tuple{typeof(Base.isbitstype), Type{QuadraticModels.PresolveOperation{Float64, Array{Float64, 1}}}}, sparams=svec(), method=isbitstype(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000523, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.last), Base.OrdinalRange{Int64, Int64}}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{Type{SparseArrays.SparseMatrixCSC{Tv, Ti} where Ti<:Integer where Tv}, Int64, Int64, Array{Int64, 1}, Array{Int64, 1}, Array{Tlow, 1} where Tlow<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dadd1720)[Core.MethodMatch(spec_types=Tuple{Type{SparseArrays.SparseMatrixCSC{Tv, Ti} where Ti<:Integer where Tv}, Int64, Int64, Array{Int64, 1}, Array{Int64, 1}, Array{Tlow, 1} where Tlow<:Real}, 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=0x000000000000980f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{LinearAlgebra.Symmetric{T, SparseArrays.SparseMatrixCSC{Tv, Int64}}} where Tv where T, SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv, Char}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ea5ddce0)[Core.MethodMatch(spec_types=Tuple{Type{LinearAlgebra.Symmetric{T, SparseArrays.SparseMatrixCSC{Tv, Int64}}}, SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv, Char} where Tv<:T where T, sparams=svec(T, S<:(SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv<:T)), method=(::Type{LinearAlgebra.Symmetric{T, S}})(Any, Char) where {T, S<:(AbstractArray{var"#s4713", 2} where var"#s4713"<:T)}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000088d9, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.StepRange{var"#s185", Int64} where var"#s185"<:Signed, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632df44e2e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.StepRange{var"#s185", Int64} where var"#s185"<:Signed, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000029f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.string), String, FillArrays.AbstractZeros{T, 1, Axes} where Axes where T, String, Array{R, 1} where R<:Real, String, FillArrays.AbstractZeros{T, 1, Axes} where Axes where T, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b85aba80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.string), String, FillArrays.AbstractZeros{T, 1, Axes} where Axes where T, String, Array{R, 1} where R<:Real, String, FillArrays.AbstractZeros{T, 1, Axes} where Axes where T, String}, sparams=svec(), method=string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003ea3, 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}, Base.ComposedFunction{Type{_A}, typeof(Base.:(-))} where _A, Tuple{Array{R, 1} where R<:Real}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b6e9a960)[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}, Base.ComposedFunction{Type{_A}, typeof(Base.:(-))} where _A, Tuple{Array{R, 1} where R<:Real}, Nothing}, sparams=svec(F<:(Base.ComposedFunction{Type{_A}, typeof(Base.:(-))} where _A)), 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=0x00000000000048f4, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LDLFactorizations.ldl_lsolve!), 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, 0x7632cce6ad20)[ Core.MethodMatch(spec_types=Tuple{typeof(LDLFactorizations.ldl_lsolve!), Int64, AbstractArray{T, 1} where T, Array{Int64, 1}, Array{Int64, 1}, Array{Tf, 1} where Tf<:Number}, sparams=svec(), method=ldl_lsolve!(Any, AbstractArray{T, 1} where T, Any, Any, Any), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(LDLFactorizations.ldl_lsolve!), Int64, AbstractArray{T, 2} where T, Array{Int64, 1}, Array{Int64, 1}, Array{Tf, 1} where Tf<:Number}, sparams=svec(), method=ldl_lsolve!(Any, AbstractArray{T, 2} where T, Any, Any, Any), fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009900, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.throw_boundserror), Base.SubArray{Tf, 1, Array{Tf, 1}, Tuple{Base.UnitRange{Int64}}, true} where Tf<:Real, Tuple{Base.UnitRange{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b8d7ce60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.throw_boundserror), Base.SubArray{Tf, 1, Array{Tf, 1}, Tuple{Base.UnitRange{Int64}}, true} where Tf<:Real, Tuple{Base.UnitRange{Int64}}}, sparams=svec(), method=throw_boundserror(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000032d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(<)), Real, Real}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(LinearOperators.storage_type), var"#s185"} where var"#s185"<: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, 0x7632ead2bf40)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(LinearOperators.storage_type), var"#s185"} where var"#s185"<: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(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_captured_variable), LinearOperators.LinearOperator{_A, Int64, F, Ft, Fct, T} where T where Fct<:(LinearOperators.var"#opDiagonal##2#opDiagonal##3"{typeof(Base.conj), var"#s185"} where var"#s185"<:AbstractArray{T, 1} where T) where Ft<:(LinearOperators.var"#opDiagonal##0#opDiagonal##1"{var"#s185"} where var"#s185"<:AbstractArray{T, 1} where T) where F<:(LinearOperators.var"#opDiagonal##0#opDiagonal##1"{var"#s185"} where var"#s185"<:AbstractArray{T, 1} where T) where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ed55b900)[Core.MethodMatch(spec_types=Tuple{typeof(Core._typeof_captured_variable), LinearOperators.LinearOperator{_A, Int64, F, Ft, Fct, T} where T where Fct<:(LinearOperators.var"#opDiagonal##2#opDiagonal##3"{typeof(Base.conj), var"#s185"} where var"#s185"<:AbstractArray{T, 1} where T) where Ft<:(LinearOperators.var"#opDiagonal##0#opDiagonal##1"{var"#s185"} where var"#s185"<:AbstractArray{T, 1} where T) where F<:(LinearOperators.var"#opDiagonal##0#opDiagonal##1"{var"#s185"} where var"#s185"<:AbstractArray{T, 1} 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(Base.getindex), AbstractArray{var"#s6", 1} where var"#s6"<:Integer, Any}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.afoldl), typeof(Base.:(+)), Any, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ca790020)[Core.MethodMatch(spec_types=Tuple{typeof(Base.afoldl), typeof(Base.:(+)), Any, Int64}, sparams=svec(), method=afoldl(Any, Any, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c1e, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.print_to_string), String, Any, String, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cb3c2dc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.print_to_string), String, Any, String, Tuple{Base.OneTo{Int64}}}, sparams=svec(), method=print_to_string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003ea0, 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, Any, Any, Array{Int64, 1}, Array{Int64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632d9f6f960)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.update_pt_aff!), Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, 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=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IndexStyle}, Base.SubArray{_A, _B, P, I, false} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632ad6cbd60)[ Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Base.SubArray{_A, _B, P, I, false} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B 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=0x0000000000000fd4, 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, Array{T, N} where N where T}}, UInt64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b6963460)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Any, Base.RefValue{T} where T, 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.getindex), AbstractArray{var"#s43", 1} where var"#s43"<:AbstractArray{T, 1} where T<:Integer, Int64}, limit=3), nothing, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), Tuple{Array{Ti, 1} where Ti<:Integer, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bb9c73e0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), Tuple{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{LinearOperators.var"##LinearOperator#14", Type{Array{T, 1}} where T, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, Type, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##6#PreconditionerData##7"{var"#s185"} where var"#s185"<:RipQP.FactorizationData{Tlow} where Tlow<:Real, Nothing, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b6150da0)[Core.MethodMatch(spec_types=Tuple{LinearOperators.var"##LinearOperator#14", Type{Array{T, 1}} where T, Type{LinearOperators.LinearOperator{T, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer where T}, Type, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##6#PreconditionerData##7"{var"#s185"} where var"#s185"<:RipQP.FactorizationData{Tlow} where Tlow<:Real, Nothing, Nothing}, sparams=svec(T, 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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Base.SubArray{_A, _B, P, I, false} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A, Base.LinearIndices{1, Tuple{Base.OneTo{Int64}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632aba31ae0)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Base.SubArray{_A, _B, P, I, false} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A, 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(StaticArrays.has_ndims), Type{StaticArraysCore.SArray{Tuple{2}, _A, N, L} where L where N} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632b780aaa0)[ Core.MethodMatch(spec_types=Tuple{typeof(StaticArrays.has_ndims), Type{StaticArraysCore.SArray{Tuple{2}, _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{2}, _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=0x0000000000009838, 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, 0x7632b86700e0)[ 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=0x0000000000004a9d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LinearAlgebra.ldiv!), LinearAlgebra.Diagonal{T, Array{T, 1}} where T<:Real, Any}, limit=3), nothing, 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, 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, 0x7632baa567e0)[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, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(), method=setproperty!(Any, Symbol, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000002a0, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.update_K!), LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4715", 2} where var"#s4715"<:T) where T<:Real, AbstractArray{T, 1} where T<:Real, RipQP.Regularization{Tlow} where Tlow, 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, 0x7632e1e4a780)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.update_K!), LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4715", 2} where var"#s4715"<:Real), 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), method=update_K!(LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4715", 2} where var"#s4715"<: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=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Expr}, Symbol, Expr, Symbol, Expr}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e1d22dc0)[Core.MethodMatch(spec_types=Tuple{Type{Expr}, Symbol, Expr, Symbol, Expr}, 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{Type{ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T}, NLPModels.NLPModelMeta{T, S} where S where T, 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"#f#98", Array{Int64, 1}, Array{Int64, 1}, Any, ADNLPModels.var"#297#298"{T} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bb6715a0)[Core.MethodMatch(spec_types=Tuple{Type{ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T}, NLPModels.NLPModelMeta{T, S}, 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"#f#98", Array{Int64, 1}, Array{Int64, 1}, Any, ADNLPModels.var"#297#298"{T} where T} where S where T, sparams=svec(T, S, Si), 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=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000984c, 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, 0x7632d97130a0)[ 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=0x0000000000004a9e, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Expr}, Symbol, Expr, Symbol, QuoteNode}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b790a5e0)[Core.MethodMatch(spec_types=Tuple{Type{Expr}, Symbol, Expr, Symbol, QuoteNode}, 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(Base._typed_vcat!), Array{_A, 1} where _A, Tuple{Array{Ti, 1} where Ti<:Integer, Base.UnitRange{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ca235820)[Core.MethodMatch(spec_types=Tuple{typeof(Base._typed_vcat!), Array{_A, 1} where _A, Tuple{Array{Ti, 1} where Ti<:Integer, Base.UnitRange{Int64}}}, sparams=svec(_A), method=_typed_vcat!(AbstractArray{T, 1}, Union{Tuple{Vararg{AbstractArray{T, 1} where T}}, AbstractArray{var"#s185", 1} where var"#s185"<:(AbstractArray{T, 1} where T)}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000013a0, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), 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}, var"#s185", typeof(Base.identity), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R} where var"#s185"<:Tuple}, limit=1), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632abd6f860)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.copyto!), 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}, var"#s185", typeof(Base.identity), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R} where var"#s185"<: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=0x0000000000004a08, 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, 0x7632ca61e370)[ 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=0x000000000000981b, 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, 0x7632ecb8e1a0)[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=0x00000000000016ab, max_world=0xffffffffffffffff), ambig=false), 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, 0x7632dce23d60)[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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core._typeof_captured_variable), 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, 0x7632ccb341e0)[Core.MethodMatch(spec_types=Tuple{typeof(Core._typeof_captured_variable), Tuple{Base.RefValue{typeof(Base.:(>))}, Array{T, N} where N where T, 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.combine_styles), Base.Broadcast.Broadcasted{Style, Nothing, typeof(SparseMatricesCOO.replace_if_minusinf), Args} where Args<:Tuple where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dc44aba0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), Base.Broadcast.Broadcasted{Style, Nothing, typeof(SparseMatricesCOO.replace_if_minusinf), Args} where Args<:Tuple 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=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004973, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.update_D!), Any, Any, Any, Any, Any, Float64, Array{Int64, 1}, Array{Int64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ea1def80)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.update_D!), AbstractArray{T, 1}, AbstractArray{T, 1}, AbstractArray{T, 1}, AbstractArray{T, 1}, AbstractArray{T, 1}, Float64, Array{Int64, 1}, Array{Int64, 1}} where T, sparams=svec(T), method=update_D!(AbstractArray{T, 1}, AbstractArray{T, 1}, AbstractArray{T, 1}, AbstractArray{T, 1}, AbstractArray{T, 1}, T, Any, Any) where {T}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(var"==")), Number, Int64}, limit=3), nothing, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.max), Real, Real}, limit=3), nothing, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), Base.SubArray{T, 1, P, I, L} where L where I where P where T, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, var"#s185", typeof(Base.:(/)), var"#s185"} where var"#s185"<:Tuple{Base.SubArray{T, 1, P, I, L} where L where I where P where T, Array{T, 1} where T<:Number} where var"#s185"<:Tuple}, limit=1), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632d975f7a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.copyto!), Base.SubArray{T, 1, P, I, L} where L where I where P where T, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, var"#s185", typeof(Base.:(/)), var"#s185"} where var"#s185"<:Tuple{Base.SubArray{T, 1, P, I, L} where L where I where P where T, Array{T, 1} where T<:Number} where var"#s185"<: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=0x0000000000004a08, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.dotgetproperty), RipQP.QM_FloatData{T, S, _A, _B} where _B where _A where S<:(AbstractArray{T, 1} where T<:Real) where T<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ec874680)[Core.MethodMatch(spec_types=Tuple{typeof(Base.dotgetproperty), RipQP.QM_FloatData{T, S, _A, _B} where _B where _A where S<:(AbstractArray{T, 1} where T<:Real) where T<:Real, Symbol}, sparams=svec(), method=dotgetproperty(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000002a2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.compute_αs), AbstractArray{T, 1} where T<:Real, AbstractArray{T, 1} where T<:Real, AbstractArray{T, 1} where T<:Real, Any, Any, Any, Any, Any, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ad2d4820)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.compute_αs), AbstractArray{T, 1} where T<:Real, AbstractArray{T, 1} where T<:Real, AbstractArray{T, 1} where T<:Real, Any, Any, Any, Any, Any, Int64}, sparams=svec(), method=compute_αs(Any, Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, 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"==")), var"#s185"} where var"#s185"<: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, 0x7632cd3e3580)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(var"==")), var"#s185"} where var"#s185"<: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(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=0x00000000000049c0, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(LinearOperators.storage_type), var"#s185"} where var"#s185"<: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}(4, 0x7632ea717d20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(LinearOperators.storage_type), var"#s185"} where var"#s185"<: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=instantiate(Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, F, Args} where Args<:Tuple where F), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004947, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.HasShape{1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ebd70e60)[Core.MethodMatch(spec_types=Tuple{Type{Base.HasShape{1}}}, sparams=svec(), method=(::Type{Base.HasShape{N}})(), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000461, 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, 0x7632cce63e60)[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=0x000000000000029f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Tuple{String, Nothing, String, Int64, String, Nothing, String, Integer, String, String, String}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e003dce0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Tuple{String, Nothing, String, Int64, String, Nothing, String, Integer, String, String, String}, Int64}, sparams=svec(), method=iterate(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006a3, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), RipQP.RipQPMonoSolver{Float64, S, Int64, _A, _B, Float64, _C, _D} where _D<:(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 _C<:(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 _B<:RipQP.ScaleData{Float64, S} where _A<:QuadraticModels.AbstractQuadraticModel{Float64, S} where S<:AbstractArray{Float64, 1}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ccef3320)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), RipQP.RipQPMonoSolver{Float64, S, Int64, _A, _B, Float64, _C, _D} where _D<:(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 _C<:(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 _B<:RipQP.ScaleData{Float64, S} where _A<:QuadraticModels.AbstractQuadraticModel{Float64, S} where S<:AbstractArray{Float64, 1}, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000029f, 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.getproperty), FillArrays.Zeros{_A, 1, Tuple{Base.OneTo{Int64}}} where _A, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e0266e60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), FillArrays.Zeros{_A, 1, Tuple{Base.OneTo{Int64}}} where _A, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000029f, 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{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, 0x7632b84b6860)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), 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(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_unaliased!), Base.IndexLinear, Base.SubArray{_A, _B, P, I, true} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A, Base.IndexLinear, Array{T, 1} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632abc9efa0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.copyto_unaliased!), Base.IndexLinear, Base.SubArray{_A, _B, P, I, true} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A, Base.IndexLinear, Array{T, 1} where T}, 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=0x00000000000012e7, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#cvt1#convert##0"{var"#s181", var"#s185"} where var"#s185"<:Tuple{AbstractArray{T, 1} where Float64<:T<:Real, Float64} where var"#s181"<:Tuple{AbstractArray{T, 1} where Float64<:T<:Real, Float64}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e06c00c0)[Core.MethodMatch(spec_types=Tuple{Base.var"#cvt1#convert##0"{var"#s181", var"#s185"} where var"#s185"<:Tuple{AbstractArray{T, 1} where Float64<:T<:Real, Float64} where var"#s181"<:Tuple{AbstractArray{T, 1} where Float64<:T<:Real, Float64}, Int64}, sparams=svec(var"#s181"<:Tuple{AbstractArray{T, 1} where Float64<:T<:Real, Float64}), method=(::Base.var"#cvt1#convert##0"{T, x})(Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000398, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Base.Broadcast.Broadcasted{Nothing, var"#s185", typeof(Base.:(/)), var"#s185"} where var"#s185"<: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)} where var"#s185"<:Tuple, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632dba91360)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Base.Broadcast.Broadcasted{Nothing, var"#s185", typeof(Base.:(/)), var"#s185"} where var"#s185"<: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)} where var"#s185"<:Tuple, LinearAlgebra.BandIndex}, sparams=svec(), method=getindex(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.getindex), Base.Broadcast.Broadcasted{Nothing, var"#s185", typeof(Base.:(/)), var"#s185"} where var"#s185"<: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)} where var"#s185"<:Tuple, Union{Integer, Base.IteratorsMD.CartesianIndex{N} where N}}, 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=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000093da, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.axes), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s185"} where var"#s185"<:Tuple{Array{Int64, 1}, Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e09f6cc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.axes), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s185"} where var"#s185"<:Tuple{Array{Int64, 1}, Real}}, 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=0x000000000000491a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{O} where O<:(ReverseDiff.TrackedArray{V, D, 1, VA, DA} where DA<:(Array{T, 1} where T<:Real) where VA<:(Array{T, 1} where T<:Real) where D<:Real where V<:Real), ReverseDiff.TrackedArray{V, D, 1, VA, DA} where DA<:(Array{T, 1} where T<:Real) where VA<:(Array{T, 1} where T<:Real) where D<:Real where V<:Real}, limit=3), nothing, 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.compute_offset1), AbstractArray{T, N} where N where T, Any, Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7632df0e53e0)[ 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), AbstractArray{T, N} where N where T, Integer, Tuple}, sparams=svec(), method=compute_offset1(Any, Integer, Tuple), fully_covers=false), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003436, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), SparseArrays.SparseMatrixCSC{Tv, Ti} where Ti<:Integer where Tv<:Float64, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632d9b6e7a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), SparseArrays.SparseMatrixCSC{Tv, Ti} where Ti<:Integer where Tv<:Float64, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000029f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{ForwardDiff.Dual{_A, V, N} where N where V} where _A, Float64, ForwardDiff.Partials{1, Bool}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632b994b9a0)[ Core.MethodMatch(spec_types=Tuple{Type{ForwardDiff.Dual{_A, V, N} where N where V} where _A, Float64, ForwardDiff.Partials{1, Bool}}, sparams=svec(_A, 1, Float64, Bool), method=(::Type{ForwardDiff.Dual{T, V, N} where N where V})(A, ForwardDiff.Partials{N, B}) where {T, N, A, B}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009830, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), RipQP.QM_FloatData{T, S, M1, M2} where M2 where M1 where S where T<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ed0be300)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), RipQP.QM_FloatData{T, S, M1, M2} where M2 where M1 where S where T<:Real, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000029f, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{AbstractArray{Float64, 1}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b928ed00)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{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{Type{Base.IndexStyle}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s185"} where var"#s185"<: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)}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632da93e540)[Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s185"} where var"#s185"<: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)}}, 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=0x000000000000492b, 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{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, 0x7632ea6fcb80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, 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=0x0000000000004917, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), AbstractArray{Float64, 1}, Base.Broadcast.Broadcasted{var"#s185", Nothing, typeof(RipQP.safe_boundary), var"#s185"} where var"#s185"<:Tuple{AbstractArray{Float64, 1}} where var"#s185"<:Base.Broadcast.BroadcastStyle}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632df4633e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), AbstractArray{Float64, 1}, Base.Broadcast.Broadcasted{var"#s185", Nothing, typeof(RipQP.safe_boundary), var"#s185"} where var"#s185"<:Tuple{AbstractArray{Float64, 1}} where var"#s185"<:Base.Broadcast.BroadcastStyle}, sparams=svec(), method=materialize!(Any, Base.Broadcast.Broadcasted{var"#s683", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s683"), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a02, 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, 0x7632e9721660)[ 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=0x000000000000980f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.fill!), Array{T, 1} where T<:Real, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632afda6420)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.fill!), Union{Array{Int8, 1}, Array{UInt8, 1}}, Integer}, sparams=svec(), method=fill!(Union{Array{Int8, N} where N, Array{UInt8, N} where N}, Integer), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.fill!), Array{T, 1} where T<:Real, Any}, sparams=svec(T<:Real), method=fill!(Array{T, N} where N, Any) where {T}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010f4, 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.identity), Tuple{Base.Broadcast.Extruded{Array{Float64, 1}, Tuple{Bool}, Tuple{Int64}}}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b9a4e080)[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.identity), Tuple{Base.Broadcast.Extruded{Array{Float64, 1}, Tuple{Bool}, Tuple{Int64}}}, Tuple{Base.OneTo{Int64}}}, 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=0x00000000000048f4, 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, 0x7632dc081dc0)[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=0x000000000000503b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LinearAlgebra.issymmetric), 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, 0x7632db3dde00)[Core.MethodMatch(spec_types=Tuple{typeof(LinearAlgebra.issymmetric), LinearOperators.LinearOperator{_A, Int64, LinearOperators.var"#119#120", LinearOperators.var"#119#120", LinearOperators.var"#119#120", T} where T where _A}, sparams=svec(), method=issymmetric(LinearOperators.AbstractLinearOperator{T} where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009848, 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"#s185"} where var"#s185"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64})}, Type{Float32}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b6e98420)[Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.real), var"#s185"} where var"#s185"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64})}, Type{Float32}}, sparams=svec(Float32), 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=0x0000000000004915, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(OperatorScaling.get_norm_rc!), Array{T, 1} where T<:Real, LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4715", 2} where var"#s4715"<:Real) where T<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632df6eece0)[ Core.MethodMatch(spec_types=Tuple{typeof(OperatorScaling.get_norm_rc!), Array{T, 1}, LinearAlgebra.Symmetric{T, SparseArrays.SparseMatrixCSC{T, Int64}}, Symbol} where T<:Real, sparams=svec(T<:Real), 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{T, 1} where T<:Real, LinearAlgebra.Symmetric{T, S} where S<:(AbstractArray{var"#s4715", 2} where var"#s4715"<:Real) where T<:Real, Symbol}, sparams=svec(T<:Real), method=get_norm_rc!(AbstractArray{T, 1}, Any, Any) where {T}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009905, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.VersionNumber}, Int32, Int64, Int64, Tuple{}, Tuple{}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632eae62460)[Core.MethodMatch(spec_types=Tuple{Type{Base.VersionNumber}, Int32, Int64, Int64, Tuple{}, Tuple{}}, sparams=svec(), method=(::Type{Base.VersionNumber})(Integer, Integer, Integer, Tuple{Vararg{Union{AbstractString, Integer}}}, Tuple{Vararg{Union{AbstractString, Integer}}}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004b81, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.maybeview), AbstractArray{T, 1} 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, 0x7632b719bd20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.maybeview), AbstractArray{T, 1} where T<:Real, 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=0x0000000000002f07, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.show_delim_array), Base.IOContext{Base.GenericIOBuffer{Memory{UInt8}}}, Array{R, 1} where R<:Real, String, String, Char, Bool, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b99d8300)[Core.MethodMatch(spec_types=Tuple{typeof(Base.show_delim_array), Base.IOContext{Base.GenericIOBuffer{Memory{UInt8}}}, Array{R, 1} where R<:Real, String, String, Char, Bool, Int64, Int64}, sparams=svec(), method=show_delim_array(IO, Union{Core.SimpleVector, AbstractArray{T, N} where N where T}, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000042ec, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Test.record), Any, Test.Error}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7632b7121460)[ Core.MethodMatch(spec_types=Tuple{typeof(Test.record), Test.ContextTestSet, Test.Error}, sparams=svec(), method=record(Test.ContextTestSet, Test.Error), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Test.record), Test.FallbackTestSet, Test.Error}, sparams=svec(), method=record(Test.FallbackTestSet, Union{Test.Error, Test.Fail}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Test.record), Test.DefaultTestSet, Test.Error}, sparams=svec(), method=record(Test.DefaultTestSet, Union{Test.Error, Test.Fail}), fully_covers=false), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009817, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"##unsafe_wrap#60", Bool, typeof(Base.unsafe_wrap), Type{Array{T, N} where N where T}, Ptr{Float64}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ea350360)[Core.MethodMatch(spec_types=Tuple{Base.var"##unsafe_wrap#60", Bool, typeof(Base.unsafe_wrap), Type{Array{T, N} where N where T}, Ptr{Float64}, Tuple{Int64}}, sparams=svec(Float64, 1), method=var"#unsafe_wrap#60"(Bool, typeof(Base.unsafe_wrap), Union{Type{Array{T, N} where N where T}, Type{Array{T, N} where N}, Type{Array{T, N}}}, Ptr{T}, Tuple{Vararg{Int64, N}}) where {T, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000cb5, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), FillArrays.Zeros{Float64, 1, Tuple{Base.OneTo{Int64}}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), var"#s185"} where var"#s185"<: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, 0x7632de4bd5c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), FillArrays.Zeros{Float64, 1, Tuple{Base.OneTo{Int64}}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), var"#s185"} where var"#s185"<:Tuple{FillArrays.Zeros{_A, 1, Tuple{Base.OneTo{Int64}}} where _A}}, sparams=svec(), method=combine_styles(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004974, 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<:Real, RipQP.LDLFactorizationData{T} where T, Int64, Int64, RipQP.Regularization{T} where T<:Real, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e08df240)[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.LDLFactorizationData{Tlow}, Int64, Int64, RipQP.Regularization{Tlow}, Any} where Tlow<:Real where T<:Real, sparams=svec(T<:Real, 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=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(var"==")), var"#s185"} where var"#s185"<: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, 0x7632ca326de0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(var"==")), var"#s185"} where var"#s185"<: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(), 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=0x000000000000491c, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.axes1), 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, 0x7632ec718220)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.axes1), 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=axes1(Base.SubArray{T, N, P, I, L} where L where I where P where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002ef5, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.real), var"#s185"} where var"#s185"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64})}, Int64, Base.IteratorsMD.CartesianIndex{0}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b67d8820)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.real), var"#s185"} where var"#s185"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64})}, 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=0x00000000000049c0, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._compute_eltype), Type{var"#s185"} where var"#s185"<: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=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632da1fb080)[Core.MethodMatch(spec_types=Tuple{typeof(Base._compute_eltype), Type{var"#s185"} where var"#s185"<: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=_compute_eltype(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006d0, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s181", var"#s185"} where var"#s185"<:Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.sqrt), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R<:Real}} where var"#s181"<:Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.sqrt), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R<:Real}}, Base.Val{1}}, limit=5), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b7778400)[Core.MethodMatch(spec_types=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s181", var"#s185"} where var"#s185"<:Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.sqrt), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R<:Real}} where var"#s181"<:Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.sqrt), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R<:Real}}, Base.Val{1}}, sparams=svec(), method=ntuple(Any, Base.Val{1}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000181a, 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{Array{R, 1} where R, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632d971d8c0)[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{Array{R, 1} where R, Any}}, 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=0x00000000000048f3, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(-)), Any, Signed}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{Type{RipQP.ScaleDataQP{T, _A}} where _A where T<:Real, Any, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ed098ee0)[Core.MethodMatch(spec_types=Tuple{Type{RipQP.ScaleDataQP{T, _A}} where _A 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=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{ADNLPModels.var"##ADNLPModel#299", String, Bool, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, Type{ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T}, SolverTest.var"#49#50", Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b92d72a0)[Core.MethodMatch(spec_types=Tuple{ADNLPModels.var"##ADNLPModel#299", String, Bool, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, Type{ADNLPModels.ADNLPModel{T, S, Si} where Si where S where T}, SolverTest.var"#49#50", Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}}, sparams=svec(Array{Float64, 1}), method=var"#ADNLPModel#299"(String, Bool, 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, S, S) where {S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000984c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), Base.Dict{Symbol, _A} where _A, Array{QuadraticModels.PresolveOperation{T, _A}, 1} where _A where T<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632ad861060)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Base.Dict{Symbol, Any}, Array{QuadraticModels.PresolveOperation{T, _A}, 1} where _A where T<:Real, Symbol}, sparams=svec(Symbol), method=setindex!(Base.Dict{K, Any}, Any, K) where {K}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Base.Dict{Symbol, _A} where _A, Array{QuadraticModels.PresolveOperation{T, _A}, 1} where _A where T<:Real, Symbol}, sparams=svec(Symbol, _A), method=setindex!(Base.Dict{K, V}, Any, K) where {K, V}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000035b9, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setproperty!), RipQP.AbstractResiduals{Float64, S} where S<:AbstractArray{Float64, 1}, Symbol, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cb8dd400)[Core.MethodMatch(spec_types=Tuple{typeof(Base.setproperty!), RipQP.AbstractResiduals{Float64, S} where S<:AbstractArray{Float64, 1}, Symbol, Any}, sparams=svec(), method=setproperty!(Any, Symbol, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000002a0, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core._typeof_captured_variable), Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bb921f20)[Core.MethodMatch(spec_types=Tuple{typeof(Core._typeof_captured_variable), 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._compute_eltype), Type{var"#s185"} where var"#s185"<: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, 0x7632ade155a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._compute_eltype), Type{var"#s185"} where var"#s185"<: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=0x00000000000006d0, 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.UnitRange{Int64}, Int64}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ecb55a20)[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}, 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=0x00000000000048f4, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{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.QuadraticModel{T0, S0, M1, M2} where M2 where M1 where S0<:AbstractArray{T0, 1} where T0<:Real, RipQP.QM_IntData, RipQP.InputConfig{I} where I<:Integer, RipQP.InputTol{T0, Int64} where T0<:Real, RipQP.ScaleDataLP{T, S} where S<:(AbstractArray{T, 1} where T<:Real) where T<:Real, RipQP.StartingPointData{T, S} where S where T<:Real, RipQP.StopCrit{Float64}, RipQP.Counters, Bool, RipQP.QM_FloatData{T, S, M1, M2} where M2 where M1 where S where T<:Real, RipQP.Tolerances{T} where T<:Real, RipQP.QM_FloatData{T, S, _A, _B} where _B where _A where S<:(AbstractArray{T, 1} where T<:Real) where T<:Real, RipQP.Tolerances{T} where T<:Real, Union{RipQP.PreallocatedFloatData{T, _A, _B, _C, _D} where _D<:RipQP.PreallocatedData{T, _A} where _C<:RipQP.DescentDirectionAllocs{T, _A} where _B<:RipQP.AbstractResiduals{T, _A} where _A, RipQP.PreallocatedFloatData{T, S, _B, _C, _D} where _D<:RipQP.PreallocatedData{T, S} where _C<:RipQP.DescentDirectionAllocs{T, S} where _B<:RipQP.AbstractResiduals{T, S} where S} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632eca5dbc0)[Core.MethodMatch(spec_types=Tuple{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}, QMType, RipQP.QM_IntData, RipQP.InputConfig{Int64}, RipQP.InputTol{T, Int64}, Sd, RipQP.StartingPointData{T1, S1}, RipQP.StopCrit{Float64}, RipQP.Counters, Bool, QMfd1, RipQP.Tolerances{T1}, QMfd2, RipQP.Tolerances{T}, Pfd} where Pfd<:(RipQP.PreallocatedFloatData{T1, S1, _B, _C, _D} where _D<:RipQP.PreallocatedData{T1, S1} where _C<:RipQP.DescentDirectionAllocs{T1, S1} where _B<:RipQP.AbstractResiduals{T1, S1}) where QMfd2<:(RipQP.QM_FloatData{T, S, _A, _B} where _B<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}} where _A<:Union{AbstractArray{T, 2}, LinearOperators.AbstractLinearOperator{T}}) where QMfd1<:(RipQP.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 Sd<:RipQP.ScaleDataLP{T, S} where QMType<:(QuadraticModels.QuadraticModel{T, S, M1, M2} where M2 where M1) where S<:AbstractArray{T, 1} where T<:Real, sparams=svec(T<:Real, S<:AbstractArray{T<:Real, 1}, Int64, QMType<:QMType<:(QuadraticModels.QuadraticModel{T<:Real, S<:AbstractArray{T<:Real, 1}, M1, M2} where M2 where M1), Sd<:Sd<:RipQP.ScaleDataLP{T<:Real, S<:AbstractArray{T<:Real, 1}}, Float64, T1<:Real, S1, QMfd1<:QMfd1<:(RipQP.QM_FloatData{T1<:Real, S1, M1, M2} where M2<:Union{AbstractArray{T1<:Real, 2}, LinearOperators.AbstractLinearOperator{T1<:Real}} where M1<:Union{AbstractArray{T1<:Real, 2}, LinearOperators.AbstractLinearOperator{T1<:Real}}), QMfd2<:QMfd2<:(RipQP.QM_FloatData{T<:Real, S<:AbstractArray{T<:Real, 1}, _A, _B} where _B<:Union{AbstractArray{T<:Real, 2}, LinearOperators.AbstractLinearOperator{T<:Real}} where _A<:Union{AbstractArray{T<:Real, 2}, LinearOperators.AbstractLinearOperator{T<:Real}}), Pfd<:Pfd<:(RipQP.PreallocatedFloatData{T1<:Real, S1, _B, _C, _D} where _D<:RipQP.PreallocatedData{T1<:Real, S1} where _C<:RipQP.DescentDirectionAllocs{T1<:Real, S1} where _B<:RipQP.AbstractResiduals{T1<:Real, S1})), method=(::Type{RipQP.RipQPDoubleSolver{T, S, I, QMType, Sd, Tsc, T1, S1, QMfd1, QMfd2, Pfd} where Pfd where QMfd2 where QMfd1 where S1 where T1 where Tsc where Sd where QMType where I where S where T})(QMType, RipQP.QM_IntData, RipQP.InputConfig{I}, RipQP.InputTol{T, I}, Sd, RipQP.StartingPointData{T1, S1}, RipQP.StopCrit{Tsc}, RipQP.Counters, Bool, QMfd1, RipQP.Tolerances{T1}, QMfd2, RipQP.Tolerances{T}, Pfd) where {T, S, I, QMType<:QuadraticModels.AbstractQuadraticModel{T, S}, Sd<:RipQP.ScaleData{T, S}, Tsc<:Real, T1, S1, 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}}), 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}}), 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})}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Type{Bool}, Array{Tv, 1} where Tv<:Float64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632b82d9120)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Type{Bool}, Array{Tv, 1} where Tv<:Float64, Int64}, sparams=svec(), method=checkbounds(Type{Bool}, Union{Array{T, N} where N where T, Memory{T} where T}, Int64), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000035f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.memoryref), Memory{T} where T<:(QuadraticModels.Row{T} where T<:Real)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ac3f46c0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.memoryref), Memory{T} where T<:(QuadraticModels.Row{T} 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.unsafe_convert), Type{Ptr{Nothing}}, GenericMemoryRef{:not_atomic, QuadraticModels.PresolveOperation{T, S}, Core.AddrSpace{Core}(0x00)} where S where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632aca8a7e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_convert), Type{Ptr{Nothing}}, GenericMemoryRef{:not_atomic, QuadraticModels.PresolveOperation{T, S}, Core.AddrSpace{Core}(0x00)} where S where T<:Real}, sparams=svec(T<:(QuadraticModels.PresolveOperation{T, S} where T<:Real where S)), method=unsafe_convert(Type{Ptr{Nothing}}, GenericMemoryRef{var"#s185", T, Core.AddrSpace{Core}(0x00)} where var"#s185") where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000cb1, 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##16#PreconditionerData##17"{var"#s185"} where var"#s185"<:RipQP.FactorizationData{Tlow} where Tlow<:Real), Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##16#PreconditionerData##17"{var"#s185"} where var"#s185"<: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, 0x7632ed0fd3e0)[Core.MethodMatch(spec_types=Tuple{Type{LinearOperators.LinearOperator{Float64, Int64, F, Nothing, Nothing, _A}} where _A where F<:(RipQP.var"#PreconditionerData##16#PreconditionerData##17"{var"#s185"} where var"#s185"<:RipQP.FactorizationData{Tlow} where Tlow<:Real), Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##16#PreconditionerData##17"{var"#s185"} where var"#s185"<: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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.cat_indices), Any, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7632df76d3a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.cat_indices), LinearAlgebra.AbstractQ{T} where T, Int64}, sparams=svec(), method=cat_indices(LinearAlgebra.AbstractQ{T} where T, Any), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.cat_indices), AbstractArray{T, N} where N where T, Int64}, sparams=svec(), method=cat_indices(AbstractArray{T, N} where N where T, Any), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.cat_indices), Any, Int64}, sparams=svec(), method=cat_indices(Any, Any), fully_covers=true), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000917c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.pointer), 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, 0x7632ca127560)[Core.MethodMatch(spec_types=Tuple{typeof(Base.pointer), 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=pointer(SparseArrays.CHOLMOD.Sparse{Tv, Ti} where Ti<:Union{Int32, Int64}) where {Tv}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000980f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s185"} where var"#s185"<: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)}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b856c7e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s185"} where var"#s185"<: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)}, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000029f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Iterators.zip), Any, Base.OneTo{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ec52cde0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators.zip), Any, Base.OneTo{Int64}}, sparams=svec(), method=zip(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000018e7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eltype), Type{var"#s185"} where var"#s185"<:Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A}}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(6, 0x7632ca75d7e0)[ 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"#s185"} where var"#s185"<:NTuple{6, Pair{Symbol, Int64}}}, sparams=svec(Pair{Symbol, Int64}), method=eltype(Type{var"#s185"} where var"#s185"<:Tuple{Vararg{E}}) where {E}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.eltype), Type{var"#s185"} where var"#s185"<:Tuple{Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, Int64}, Pair{Symbol, _A} where _A, Pair{Symbol, _A} where _A}}, sparams=svec(), method=eltype(Type{var"#s185"} where var"#s185"<:Tuple), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001279, 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.identity), Tuple{AbstractArray{Float64, 1}}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b820d440)[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.identity), Tuple{AbstractArray{Float64, 1}}, Nothing}, 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=0x00000000000048f4, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{NamedTuple{(:lvar, :uvar, :ncon, :lcon, :ucon, :nnzj, :lin_nnzj, :nln_nnzj, :nnzh, :lin, :islp, :minimize), T} where T<:Tuple}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Int64, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Int64, Int64, Base.UnitRange{Int64}, Bool, Bool}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ec06dce0)[Core.MethodMatch(spec_types=Tuple{Type{NamedTuple{(:lvar, :uvar, :ncon, :lcon, :ucon, :nnzj, :lin_nnzj, :nln_nnzj, :nnzh, :lin, :islp, :minimize), T} where T<:Tuple}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Int64, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Int64, Int64, Base.UnitRange{Int64}, Bool, Bool}}, sparams=svec((:lvar, :uvar, :ncon, :lcon, :ucon, :nnzj, :lin_nnzj, :nln_nnzj, :nnzh, :lin, :islp, :minimize)), method=(::Type{NamedTuple{names, T} where T<:Tuple})(Tuple) where {names}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000019a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Tuple{FillArrays.AbstractZeros{T, N, Axes} where Axes where N where T, Array{R, 1} where R<:Real}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632d9b6f520)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Tuple{FillArrays.AbstractZeros{T, N, Axes} where Axes where N where T, Array{R, 1} where R<:Real}, Int64}, sparams=svec(), method=getindex(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), RipQP.RipQPDoubleParameters{Float64, RipQP.K2LDLParams{Float64, RipQP.LDLFact}, _A, RipQP.PC, RipQP.PC} where _A<:RipQP.SolverParams{Float64}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bb4bb6e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), RipQP.RipQPDoubleParameters{Float64, RipQP.K2LDLParams{Float64, RipQP.LDLFact}, _A, RipQP.PC, RipQP.PC} where _A<:RipQP.SolverParams{Float64}, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000029f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.tail), Tuple{Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cb08fc80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.tail), Tuple{Any}}, sparams=svec(), method=tail(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000037d, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.axes), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632eb8c1fc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.axes), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), var"#s185"} where var"#s185"<:Tuple{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=0x000000000000491a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_type), Any, Type{Bool}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7632d97b4560)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_type), Type{Union{}}, Type{Bool}}, sparams=svec(Bool), method=promote_type(Type{Union{}}, Type{T}) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_type), Type{Bool}, Type{Bool}}, sparams=svec(Bool), method=promote_type(Type{T}, Type{T}) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_type), Type{T}, Type{Bool}} where T, sparams=svec(T, Bool), method=promote_type(Type{T}, Type{S}) where {T, S}, fully_covers=false), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000621, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Tuple{String, Int64, String, Nothing, String, Nothing, String, Nothing, String, String, Vararg{String}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ca4f31a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Tuple{String, Int64, String, Nothing, String, Nothing, String, Nothing, String, String, Vararg{String}}}, sparams=svec(), method=iterate(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006a2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type, Memory{QuadraticModels.PresolvedQuadraticModel{Float64, Array{Float64, 1}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}}}}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), var"#s185"} where var"#s185"<: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}(4, 0x7632defcb160)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), var"#s185"} where var"#s185"<:Tuple{FillArrays.Zeros{_A, 1, Tuple{Base.OneTo{Int64}}} 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=0x0000000000004945, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.CoreLogging.handle_message_nothrow), Base.CoreLogging.AbstractLogger, Base.CoreLogging.LogLevel, Base.AnnotatedString{String}, Module, Symbol, Symbol, String, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632caabc1e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.CoreLogging.handle_message_nothrow), Base.CoreLogging.AbstractLogger, Base.CoreLogging.LogLevel, Base.AnnotatedString{String}, Module, Symbol, Symbol, String, Int64}, sparams=svec(), method=handle_message_nothrow(Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000503a, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.sqrt), AbstractArray{T, 1} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632dcd04620)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.sqrt), AbstractArray{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=0x0000000000004a9c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), Any, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.abs), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632adccbaa0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.Broadcast.BitMaskedBitArray{N, M} where M where N, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.abs), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R}}, sparams=svec(), method=materialize!(Base.Broadcast.BitMaskedBitArray{N, M} where M where N, Base.Broadcast.Broadcasted{var"#s683", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s683"), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Any, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.abs), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R}}, sparams=svec(), method=materialize!(Any, Base.Broadcast.Broadcasted{var"#s683", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s683"), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a81, 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, 0x7632eab1ef00)[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=0x0000000000000c58, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.tail), Tuple{Base.IteratorsMD.CartesianIndex{N} where N}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cb7fa580)[Core.MethodMatch(spec_types=Tuple{typeof(Base.tail), Tuple{Base.IteratorsMD.CartesianIndex{N} where N}}, sparams=svec(), method=tail(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000037d, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isempty), Tuple{String, Type, String, Type, String, Type, String, Type, String, Type, String, Type, String}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632daae9de0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.isempty), Tuple{String, Type, String, Type, String, Type, String, Type, String, Type, String, Type, String}}, sparams=svec(), method=isempty(Tuple), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000074b, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.maybeview), Any, Base.Colon, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7632e1deef20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.maybeview), AbstractString, Base.Colon, Any}, sparams=svec(), method=maybeview(AbstractString, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.maybeview), AbstractArray{T, N} where N where T, Base.Colon, Any}, sparams=svec(), method=maybeview(AbstractArray{T, N} where N where T, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.maybeview), Any, Base.Colon, Any}, sparams=svec(), method=maybeview(Any, Any...), fully_covers=true), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003845, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.TwicePrecision{Float32}}, Float32}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632b36187e0)[ Core.MethodMatch(spec_types=Tuple{Type{Base.TwicePrecision{Float32}}, Float32}, sparams=svec(Float32), method=(::Type{Base.TwicePrecision{T}})(T) where {T}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002f97, 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"#s185"} where var"#s185"<: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, 0x7632e0c36f20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), Base.IndexLinear, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s185"} where var"#s185"<: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=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=0x0000000000004926, 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"{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, 0x7632de1fef60)[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"{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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s181"} where var"#s181"<:Tuple{Array{R, 1} where R}, Tuple{Array{R, 1} where R}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7632cdc7da60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Tuple{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{Array{R, 1} where R}} where T<:Tuple{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"#s181"} where var"#s181"<:Tuple{Array{R, 1} where R}, Tuple{Array{R, 1} where R}}, sparams=svec(1, var"#s181"<:Tuple{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=0x0000000000000399, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), Array{T, 1} where T<:(QuadraticModels.PresolveOperation{T, _A} where T<:Real where _A)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ac2dd880)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), Array{T, 1} where T<:(QuadraticModels.PresolveOperation{T, _A} where T<:Real where _A)}, sparams=svec(), method=size(Array{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010c1, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s181"} where var"#s181"<:Tuple{Any, Array{Float64, 1}}, Tuple{Any, Array{Float64, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7632ed112ee0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Tuple{Any, Array{Float64, 1}}}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, Tuple{Any, Array{Float64, 1}}} where T<:Tuple{Any, Array{Float64, 1}}, 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"#s181"} where var"#s181"<:Tuple{Any, Array{Float64, 1}}, Tuple{Any, Array{Float64, 1}}}, sparams=svec(2, var"#s181"<:Tuple{Any, Array{Float64, 1}}), method=convert(Type{T}, Tuple{Vararg{Any, N}}) where {N, T<:Tuple}, fully_covers=true), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000399, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eltype), Type{var"#s185"} where var"#s185"<:AbstractArray{T, 1} where T<:Real}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(6, 0x7632ad4478b0)[ 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"#s185"} where var"#s185"<:AbstractArray{T, 1} where T<:Real}, sparams=svec(T<:Real), method=eltype(Type{var"#s185"} where var"#s185"<:(AbstractArray{E, N} where N)) where {E}, fully_covers=true), #, #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000127b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.throw_boundserror), Base.Broadcast.Broadcasted{Nothing, var"#s185", typeof(Base.:(/)), var"#s185"} where var"#s185"<: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)} where var"#s185"<:Tuple, Tuple{Base.IteratorsMD.CartesianIndex{2}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dc9c50a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.throw_boundserror), Base.Broadcast.Broadcasted{Nothing, var"#s185", typeof(Base.:(/)), var"#s185"} where var"#s185"<: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)} where var"#s185"<:Tuple, Tuple{Base.IteratorsMD.CartesianIndex{2}}}, sparams=svec(), method=throw_boundserror(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000032d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_axes), Array{R, 1} where R<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e0a25300)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_axes), Array{R, 1} where R<:Real}, sparams=svec(), method=combine_axes(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004985, 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, Integer, Integer, Bool, Bool, LinearOperators.var"#opDiagonal##0#opDiagonal##1"{var"#s185"} where var"#s185"<:AbstractArray{T, 1} where T, LinearOperators.var"#opDiagonal##0#opDiagonal##1"{var"#s185"} where var"#s185"<:AbstractArray{T, 1} where T, LinearOperators.var"#opDiagonal##2#opDiagonal##3"{typeof(Base.conj), var"#s185"} where var"#s185"<:AbstractArray{T, 1} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ebdef080)[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}, I, I, Bool, Bool, LinearOperators.var"#opDiagonal##0#opDiagonal##1"{var"#s185"} where var"#s185"<:AbstractArray{T, 1} where T, LinearOperators.var"#opDiagonal##0#opDiagonal##1"{var"#s185"} where var"#s185"<:AbstractArray{T, 1} where T, LinearOperators.var"#opDiagonal##2#opDiagonal##3"{typeof(Base.conj), var"#s185"} where var"#s185"<:AbstractArray{T, 1} where T} where I<:Integer where T, sparams=svec(T, I<:I<:Integer), 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=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.signature_type), RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Type{Tuple}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ec109340)[Core.MethodMatch(spec_types=Tuple{typeof(Base.signature_type), RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Type{Tuple}}, sparams=svec(), method=signature_type(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000569, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s185"} where var"#s185"<: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, 0x7632db48afa0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s185"} where var"#s185"<: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(), 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=0x000000000000491c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.iszero)}, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cdccd8e0)[Core.MethodMatch(spec_types=Tuple{Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.iszero)}, Any}, sparams=svec(), method=(::Base.ComposedFunction{O, I})(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c54, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Ref{Union{}}}, Array{T, 1} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b880fbc0)[Core.MethodMatch(spec_types=Tuple{Type{Ref{Union{}}}, Array{T, 1} where T<:Real}, sparams=svec(T<:Real, Union{}), method=(::Type{Ref{P}})(Array{T, N} where N) where {T, P<:Union{Base.Cstring, Base.Cwstring, Ptr{T} where T}}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002e15, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), 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, 0x7632e08daf20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), FillArrays.Zeros{_A, 1, Tuple{Base.OneTo{Int64}}} where _A}, sparams=svec(), method=combine_styles(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004972, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Type{Base.BitArray{N} where N}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ea6fe680)[Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Type{Base.BitArray{N} where N}, Tuple{Int64}}, sparams=svec(Base.BitArray{N} where N), method=similar(Type{T}, Tuple{Vararg{Int64, N}} where N) where {T<:(AbstractArray{T, N} where N where T)}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012d6, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.string), String, Type{Tuple{1}}, String, Int64, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dc449d40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.string), String, Type{Tuple{1}}, String, Int64, String}, sparams=svec(), method=string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003ea3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setproperty!), RipQP.Regularization{Tlow} where Tlow<:Union{Float32, Float64}, Symbol, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cd003940)[Core.MethodMatch(spec_types=Tuple{typeof(Base.setproperty!), RipQP.Regularization{Tlow} where Tlow<:Union{Float32, Float64}, Symbol, Symbol}, sparams=svec(), method=setproperty!(Any, Symbol, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000002a0, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.methods), 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}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dcff5ac0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.methods), 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}, 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=0x00000000000005a1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Dict{T, T}} where T where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dea974c0)[Core.MethodMatch(spec_types=Tuple{Type{Base.Dict{T, T}} where T where T}, sparams=svec(T, T), method=(::Type{Base.Dict{K, V}})() where {K, V}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000358d, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.zero), Type{Tf} where Tf<:Number}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(MatrixMarket.mmwrite), Base.IOStream, SparseArrays.SparseMatrixCSC{T, Int64} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632db652fa0)[Core.MethodMatch(spec_types=Tuple{typeof(MatrixMarket.mmwrite), Base.IOStream, SparseArrays.SparseMatrixCSC{T, Int64} where T<:Real}, sparams=svec(), method=mmwrite(IO, SparseArrays.SparseMatrixCSC{Tv, Ti} where Ti<:Integer where Tv), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000098e4, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseArrays.nnz), SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv<:Number}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b813c1c0)[Core.MethodMatch(spec_types=Tuple{typeof(SparseArrays.nnz), SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv<:Number}, sparams=svec(), method=nnz(SparseArrays.AbstractSparseMatrixCSC{Tv, Ti} where Ti<:Integer where Tv), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000980f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), var"#s185"} where var"#s185"<: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"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real, Nothing, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632da905d40)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), var"#s185"} where var"#s185"<: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"{RipQP.LDLFactorizationData{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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), 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, 0x7632e1778f00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Tuple{String, Nothing, String, Int64, String, Nothing, String, Nothing, String, String, Vararg{String}}, Int64}, sparams=svec(), method=iterate(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006a3, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.one), Type{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e171d100)[Core.MethodMatch(spec_types=Tuple{typeof(Base.one), Type{Int64}}, sparams=svec(Int64), method=one(Type{T}) where {T<:Number}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000aac, 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"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R<:Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dd14e8e0)[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"#s185"} where var"#s185"<: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=0x0000000000004a0e, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s185"} where var"#s185"<:Tuple{Array{Int64, 1}, Real}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e09f7c00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s185"} where var"#s185"<:Tuple{Array{Int64, 1}, Real}, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000029f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), Any, AbstractArray{Float64, 1}, Base.Broadcast.Broadcasted{var"#s185", Nothing, typeof(Base.identity), var"#s185"} where var"#s185"<:Tuple{AbstractArray{Float64, 1}} where var"#s185"<:Base.Broadcast.BroadcastStyle}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b75f08a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.Broadcast.BroadcastStyle, AbstractArray{Float64, 1}, Base.Broadcast.Broadcasted{var"#s185", Nothing, typeof(Base.identity), var"#s185"} where var"#s185"<:Tuple{AbstractArray{Float64, 1}} where var"#s185"<:Base.Broadcast.BroadcastStyle}, sparams=svec(), method=materialize!(Base.Broadcast.BroadcastStyle, Any, Base.Broadcast.Broadcasted{var"#s683", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s683"), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a03, 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, 0x7632da171a80)[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=0x0000000000009907, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.parent), SparseArrays.ReadOnly{T, 2, V} where V<:AbstractArray{T, 2} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e1d00120)[Core.MethodMatch(spec_types=Tuple{typeof(Base.parent), SparseArrays.ReadOnly{T, 2, V} where V<:AbstractArray{T, 2} where T<:Real}, sparams=svec(), method=parent(SparseArrays.ReadOnly{T, N, V} where V<:AbstractArray{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000980f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{AbstractArray{T, 1} where T<:Real, Array{R, 1} where R<:Real}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b8df5f20)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{AbstractArray{T, 1} where T<:Real, Array{R, 1} where R<:Real}}}, 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(LinearOperators.storage_type), LinearOperators.AbstractLinearOperator{T} where T}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{FillArrays.Fill{T, N, Axes} where Axes where N where T}}, UInt64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e974b7e0)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{FillArrays.Fill{T, N, Axes} where Axes 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.:(-)), Int64, Any}, limit=3), nothing, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Any, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R, Array{R, 1} where R}}}, UInt64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cd8d4840)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Any, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R, Array{R, 1} where R}}}, 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.reshape), Base.SubArray{T, 1, A, I, LD} where LD where I<:Tuple{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}}}} where A<:(Array{T, N} where N where T) where T, Any}, limit=3), nothing, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eachindex), Base.IndexLinear, 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, 0x7632b8e9fbe0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), Base.IndexLinear, FillArrays.AbstractFill{T, 1, Axes} where Axes where Float64<:T<:Real}, sparams=svec(), method=eachindex(Base.IndexLinear, AbstractArray{T, 1} where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000128e, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{Any, Tuple}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ec18a2c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{Any, Tuple}, Int64, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006ae, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.throw_boundserror), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.real), var"#s185"} where var"#s185"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64})}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b67f1c40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.throw_boundserror), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.real), var"#s185"} where var"#s185"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{Base.Complex{T}, 1} where T<:Union{Float32, Float64})}, Tuple{Int64}}, sparams=svec(), method=throw_boundserror(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000032d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{NamedTuple{(:status, :solution, :iter, :elapsed_time, :solver_specific), T} where T<:Tuple}, Tuple{Symbol, Any, Int64, Float64, Base.Dict{Symbol, Nothing}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ac25dac0)[Core.MethodMatch(spec_types=Tuple{Type{NamedTuple{(:status, :solution, :iter, :elapsed_time, :solver_specific), T} where T<:Tuple}, Tuple{Symbol, Any, Int64, Float64, Base.Dict{Symbol, Nothing}}}, sparams=svec((:status, :solution, :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=0x000000000000019a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"##minimum#750", Base.Colon, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), 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}(1, 0x7632dbe0a780)[Core.MethodMatch(spec_types=Tuple{Base.var"##minimum#750", Base.Colon, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), 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=var"#minimum#750"(Any, 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.minimum), AbstractArray{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000005b0d, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{LinearOperators.var"##_#2", 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, QuadraticModels.var"#opPermutedMinusOnes##0#opPermutedMinusOnes##1"{Array{Int64, 1}}, QuadraticModels.var"#opPermutedMinusOnes##2#opPermutedMinusOnes##3"{Array{Int64, 1}}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bbbd49c0)[Core.MethodMatch(spec_types=Tuple{LinearOperators.var"##_#2", 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, QuadraticModels.var"#opPermutedMinusOnes##0#opPermutedMinusOnes##1"{Array{Int64, 1}}, QuadraticModels.var"#opPermutedMinusOnes##2#opPermutedMinusOnes##3"{Array{Int64, 1}}, Nothing}, sparams=svec(_A, 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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(+)), Any, Float16}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s181"} where var"#s181"<:(Tuple{Vararg{Float64, _A}} where _A), Any}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._tuple_error), Type{var"#s181"} where var"#s181"<:Tuple{Base.RefValue{typeof(Base.:(<))}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T}, Tuple{Base.RefValue{typeof(Base.:(<))}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632d9ef5dc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._tuple_error), Type{var"#s181"} where var"#s181"<:Tuple{Base.RefValue{typeof(Base.:(<))}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T}, Tuple{Base.RefValue{typeof(Base.:(<))}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T}}, sparams=svec(), method=_tuple_error(Type, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000394, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Type{Array{QuadraticModels.Col{Float64}, 1}}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632e04a0e60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Type{Array{QuadraticModels.Col{Float64}, 1}}, Tuple{Int64}}, sparams=svec(Array{QuadraticModels.Col{Float64}, 1}), method=similar(Type{T}, Tuple{Vararg{Int64, N}} where N) where {T<:(AbstractArray{T, N} where N where T)}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012d6, 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{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, 0x7632eb8f0040)[Core.MethodMatch(spec_types=Tuple{typeof(Base.methods), 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(), method=methods(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000005a0, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Iterators._zip_iterate_all), Tuple{Base.OneTo{Int64}, Any}, Tuple{Tuple{}, Tuple{}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cb0fc160)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators._zip_iterate_all), Tuple{Base.OneTo{Int64}, Any}, Tuple{Tuple{}, Tuple{}}}, sparams=svec(), method=_zip_iterate_all(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001906, 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, 0x7632cde8a360)[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=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unsafe_convert), Type{Ptr{Ptr{SparseArrays.LibSuiteSparse.cholmod_sparse_struct}}}, Base.RefValue{Ptr{SparseArrays.LibSuiteSparse.cholmod_sparse_struct}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ec43c3e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_convert), Type{Ptr{Ptr{SparseArrays.LibSuiteSparse.cholmod_sparse_struct}}}, Base.RefValue{Ptr{SparseArrays.LibSuiteSparse.cholmod_sparse_struct}}}, sparams=svec(Ptr{SparseArrays.LibSuiteSparse.cholmod_sparse_struct}), method=unsafe_convert(Union{Type{Ptr{T}}, Type{Ptr{Nothing}}}, Base.RefValue{T}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000cf7, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s181"} where var"#s181"<:Tuple{Base.RefValue{typeof(Base.min)}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T}, Tuple{Base.RefValue{typeof(Base.min)}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7632da747120)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Tuple{Base.RefValue{typeof(Base.min)}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T}}, 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.min)}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T}} where T<:Tuple{Base.RefValue{typeof(Base.min)}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T}, 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"#s181"} where var"#s181"<:Tuple{Base.RefValue{typeof(Base.min)}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T}, Tuple{Base.RefValue{typeof(Base.min)}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T}}, sparams=svec(3, var"#s181"<:Tuple{Base.RefValue{typeof(Base.min)}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T}), method=convert(Type{T}, Tuple{Vararg{Any, N}}) where {N, T<:Tuple}, fully_covers=true), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000399, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.update_diag_K11!), LinearAlgebra.Symmetric{T, _B} where _B<:AbstractArray{T, 2} where T<:Real, AbstractArray{T, 1} where T<:Real, Array{Int64, 1}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632df55ece0)[ Core.MethodMatch(spec_types=Tuple{typeof(RipQP.update_diag_K11!), LinearAlgebra.Symmetric{T, _B} where _B<:(SparseArrays.SparseMatrixCSC{T, Ti} where Ti<:Integer), AbstractArray{T, 1} where T<:Real, Array{Int64, 1}, Int64} where T<:Real, sparams=svec(T<:Real), method=update_diag_K11!(LinearAlgebra.Symmetric{T, var"#s44"} where var"#s44"<:(SparseArrays.SparseMatrixCSC{Tv, Ti} where Ti<:Integer where Tv), Any, Any, Any) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(RipQP.update_diag_K11!), LinearAlgebra.Symmetric{T, _B} where _B<:(SparseMatricesCOO.SparseMatrixCOO{T, Ti} where Ti<:Integer), AbstractArray{T, 1} where T<:Real, Array{Int64, 1}, Int64} where T<:Real, sparams=svec(T<:Real), method=update_diag_K11!(LinearAlgebra.Symmetric{T, var"#s44"} where var"#s44"<:(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv), Any, Any, Any) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, max_world=0xffffffffffffffff), ambig=true), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.cconvert), Type{Ptr{SparseArrays.LibSuiteSparse.cholmod_sparse_struct}}, SparseArrays.CHOLMOD.Sparse{T, Int64} where T<:Union{Float32, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632b90a6be0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.cconvert), Type{Ptr{SparseArrays.LibSuiteSparse.cholmod_sparse_struct}}, SparseArrays.CHOLMOD.Sparse{T, Int64} where T<:Union{Float32, Float64}}, sparams=svec(), method=cconvert(Type{var"#s66"} where var"#s66"<:(Ptr{T} where T), Any), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000003a4, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), 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}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dd134c60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), 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}, Int64}, sparams=svec(), method=iterate(Base.Generator{I, F} where F where I, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000044b, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s181"} where var"#s181"<:(LinearOperators.var"#*##2#*##3"{LinearOperators.LinearOperator{T, I, F, Ft, Fct, 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 Fct where Ft where F where I<:Integer where T), LinearOperators.var"#*##2#*##3"{LinearOperators.LinearOperator{T, I, F, Ft, Fct, 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 Fct where Ft where F where I<:Integer where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632dbff7d60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, LinearOperators.var"#*##2#*##3"{LinearOperators.LinearOperator{T, I, F, Ft, Fct, 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 Fct where Ft where F where I<:Integer where T}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, LinearOperators.var"#*##2#*##3"{LinearOperators.LinearOperator{T, I, F, Ft, Fct, 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 Fct where Ft where F where I<:Integer where T} where T<:(LinearOperators.var"#*##2#*##3"{LinearOperators.LinearOperator{T, I, F, Ft, Fct, 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 Fct where Ft where F where I<:Integer where T), sparams=svec(T), method=convert(Type{T}, T) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000036c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(*)), AbstractArray{T, 1} where T<:Real, Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632b920e2e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(*)), AbstractArray{T, 1} where T<:Real, Real}, sparams=svec(typeof(Base.:(*))), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a9d, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{var"#s181"} where var"#s181"<:(Array{QuadraticModels.Col{T}, 1} where T<:Real), Array{QuadraticModels.Col{T}, 1} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632ac3942e0)[ Core.MethodMatch(spec_types=Tuple{Type{Union{}}, Array{QuadraticModels.Col{T}, 1} where T}, sparams=svec(), method=(::Type{Union{}})(Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{Array{QuadraticModels.Col{T}, 1}}, Array{QuadraticModels.Col{T}, 1}} where T where T<:Real, sparams=svec(T<:(QuadraticModels.Col{T} where T<:Real), 1, S<:(QuadraticModels.Col{T} where T)), method=(::Type{Array{T, N}})(AbstractArray{S, N}) where {T, N, S}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001113, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{V} where V<:Real, Int64}, limit=3), nothing, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, limit=3), nothing, 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.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, LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothing, T} where T where F<:(RipQP.var"#PreconditionerData##16#PreconditionerData##17"{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}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ad5277c0)[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.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, LinearOperators.LinearOperator{T, Int64, F, Nothing, Nothingmethod=var"=="(Type, Type), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000bfb, 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, 0x7632ac2dc640)[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=0x00000000000012f0, 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, false} 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"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632aba739e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.Broadcast.DefaultArrayStyle{N} where N, 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}, Nothing, typeof(Base.identity), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R}}, sparams=svec(), method=materialize!(Base.Broadcast.BroadcastStyle, Any, Base.Broadcast.Broadcasted{var"#s683", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s683"), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a03, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LinearAlgebra.tril), SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv<:Number, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b7e5ad60)[Core.MethodMatch(spec_types=Tuple{typeof(LinearAlgebra.tril), SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv<:Number, Int64}, sparams=svec(Tv<:Number, Int64), method=tril(SparseArrays.AbstractSparseMatrixCSC{Tv, Ti}, Integer) where {Tv, Ti}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000980f, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{ft} where ft<:(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)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632cde9bde0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, 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{_A, 1} where _A)} where T<:(Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)), sparams=svec(T), method=convert(Type{T}, T) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000036c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), Array{Ti, 1} where Ti<:Integer, Any, Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632ebb8c0a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Array{T, 1}, Any, Int64} where T<:Integer, sparams=svec(T<:Integer), method=setindex!(Array{T, N} where N, Any, Int64) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Array{Ti, 1} where Ti<:Integer, 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=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type, AbstractArray{T, 1} where T}, limit=3), nothing, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isempty), Tuple{String, String, Int64, String, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632dfdc3960)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.isempty), Tuple{String, String, Int64, String, Any}}, sparams=svec(), method=isempty(Tuple), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000074b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Generator{I, F} where F where I}, LinearOperators.var"#143#144", 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, 0x7632dba63ae0)[Core.MethodMatch(spec_types=Tuple{Type{Base.Generator{I, F} where F where I}, LinearOperators.var"#143#144", 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(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}, LinearOperators.var"#143#144"), 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=0x0000000000000440, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.length), Tuple{Int64, Any, Any, Any, Any, Float64, Float64, Any, Float64, Float64, Int64, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cb67a8e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.length), Tuple{Int64, Any, Any, Any, Any, Float64, Float64, Any, Float64, Float64, Int64, Any}}, sparams=svec(), method=length(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000068c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.preprocess_args), Base.BitArray{1}, Tuple{Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e0900820)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.preprocess_args), Base.BitArray{1}, Tuple{Real}}, sparams=svec(), method=preprocess_args(Any, Tuple{Any}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a12, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{QuadraticModels.Col{T} where T, Int64}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ade97780)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{QuadraticModels.Col{T} where T, Int64}, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006ad, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.floatrange), Type{Float16}, Int64, Int64, Any, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bb45f040)[Core.MethodMatch(spec_types=Tuple{typeof(Base.floatrange), Type{Float16}, Int64, Int64, Integer, Int64}, sparams=svec(Float16), method=floatrange(Type{T}, Integer, Integer, Integer, Integer) where {T}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002fcf, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.:(-)), Array{Ti, 1} where Ti<:Integer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632db3fab20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.:(-)), Array{Ti, 1} where Ti<:Integer, Int64}, sparams=svec(typeof(Base.:(-))), method=broadcasted(Base.Broadcast.BroadcastStyle, F, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a9e, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.merge), NamedTuple{(:lo, :hi, :legacy_dispatch_entry), var"#s185"} where var"#s185"<:Tuple{Integer, Integer, Base.Sort.InsertionSortAlg}, NamedTuple{(:scratch,), Tuple{Nothing}}}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632db2ce9e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.merge), NamedTuple{(:lo, :hi, :legacy_dispatch_entry), var"#s185"} where var"#s185"<:Tuple{Integer, Integer, Base.Sort.InsertionSortAlg}, NamedTuple{(:scratch,), Tuple{Nothing}}}, sparams=svec((:lo, :hi, :legacy_dispatch_entry), (:scratch,)), 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=0x0000000000001ae9, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s181", var"#s185"} where var"#s185"<: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}} where var"#s181"<: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}}, Base.Val{4}}, limit=5), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632d93e29a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s181", var"#s185"} where var"#s185"<: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}} where var"#s181"<: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}}, Base.Val{4}}, sparams=svec(F<:(Base.var"#cvt1#convert##0"{var"#s181", var"#s185"} where var"#s185"<: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}} where var"#s181"<: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}}), 4), method=ntuple(F, Base.Val{N}) where {F, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001823, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Memory{Base.Complex{T}} where T<:Union{Float32, Float64}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b73471e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Memory{Base.Complex{T}} where T<:Union{Float32, Float64}, Int64}, sparams=svec(), method=checkbounds(Union{Array{T, N} where N where T, GenericMemory{isatomic, T, addrspace} where addrspace where T where isatomic}, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000360, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Array{T, N} where N} where T, Array{T, 1} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cd261a60)[Core.MethodMatch(spec_types=Tuple{Type{Array{T, N} where N} where T, Array{T, 1} where T}, sparams=svec(T, 1, T), method=(::Type{Array{T, N} where N})(AbstractArray{S, N}) where {T, N, S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000126, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseArrays.dropzeros!), SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632eaae9060)[Core.MethodMatch(spec_types=Tuple{typeof(SparseArrays.dropzeros!), SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv}, sparams=svec(), method=dropzeros!(SparseArrays.AbstractSparseMatrixCSC{Tv, Ti} where Ti<:Integer where Tv), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000980f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s181"} where var"#s181"<:(RipQP.var"#PreconditionerData##6#PreconditionerData##7"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}), RipQP.var"#PreconditionerData##6#PreconditionerData##7"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632ad01ca60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, RipQP.var"#PreconditionerData##6#PreconditionerData##7"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}}, 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"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}} where T<:(RipQP.var"#PreconditionerData##6#PreconditionerData##7"{RipQP.CholmodFactorization{Tlow}} where Tlow<:Union{Float32, Float64}), sparams=svec(T), method=convert(Type{T}, T) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000036c, 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, 0x7632baa2cb20)[ 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=0x0000000000004a9d, 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{0}, typeof(Base.:(+)), Tuple{Int64, Int64}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b8022ca0)[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{0}, typeof(Base.:(+)), Tuple{Int64, 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=0x00000000000048f4, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), Memory{V} where V<:(QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2} where T where S where M1 where M2), Int64, Memory{S} where S<:(QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2} where T where S where M1 where M2), Int64, Int64}, limit=1), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b9855080)[Core.MethodMatch(spec_types=Tuple{typeof(Base.copyto!), Memory{V} where V<:(QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2} where T where S where M1 where M2), Int64, Memory{S} where S<:(QuadraticModels.PresolvedQuadraticModel{T, S, M1, M2} where T where S where M1 where M2), Int64, Int64}, sparams=svec(), method=copyto!(Memory{T} where T, Integer, Memory{T} where T, Integer, Integer), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001079, 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, 0x7632da1045c0)[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=0x0000000000004a0b, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Array{Tf, 1} where Tf<:Real, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b9022a80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Array{Tf, 1} where Tf<:Real, Int64}, sparams=svec(), method=getindex(Array{T, N} where N where T, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000003bb, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setproperty!), RipQP.Point{Float64, S} where S<:AbstractArray{T, 1} where T<:Real, Symbol, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ead288a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.setproperty!), RipQP.Point{Float64, S} where S<:AbstractArray{T, 1} where T<:Real, Symbol, Any}, sparams=svec(), method=setproperty!(Any, Symbol, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000002a0, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.TupleOrBottom), Type{Int64}, Type{Base.Rational{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ecb6dfc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.TupleOrBottom), Type{Int64}, Type{Base.Rational{Int64}}}, sparams=svec(), method=TupleOrBottom(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000668, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#overflow_case#steprange_last##0", Signed, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b97e34a0)[Core.MethodMatch(spec_types=Tuple{Base.var"#overflow_case#steprange_last##0", Signed, Any}, sparams=svec(), method=overflow_case(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000008a1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Base.Generator{Base.UnitRange{Int64}, F} where F<:(QuadraticModels.var"#get_arows_acols##2#get_arows_acols##3"{_A, Array{Int64, 1}} where _A), Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632add4cc20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Base.Generator{Base.UnitRange{Int64}, F} where F<:(QuadraticModels.var"#get_arows_acols##2#get_arows_acols##3"{_A, Array{Int64, 1}} where _A), Int64}, sparams=svec(), method=iterate(Base.Generator{I, F} where F where I, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000044b, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(RipQP.ripqp_solver_specific), QuadraticModels.AbstractQuadraticModel{Float64, S} where S, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632da269b00)[Core.MethodMatch(spec_types=Tuple{typeof(RipQP.ripqp_solver_specific), QuadraticModels.AbstractQuadraticModel{Float64, S} where S, Bool}, sparams=svec(Float64), method=ripqp_solver_specific(QuadraticModels.AbstractQuadraticModel{T, S} where S, Bool) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._push!), Array{T, 1} where T<:Real, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632badf1e00)[Core.MethodMatch(spec_types=Tuple{typeof(Base._push!), Array{T, 1}, Real} where T<:Real, sparams=svec(T), method=_push!(Array{T, 1}, T) where {T}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000116c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), Array{Int64, 1}, Int64, Vararg{Any}}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.allocatedinline), Type{CodecZlib.ZStream}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bb3bd700)[Core.MethodMatch(spec_types=Tuple{typeof(Base.allocatedinline), Type{CodecZlib.ZStream}}, sparams=svec(), method=allocatedinline(Type), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010c5, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Nothing, var"#s185", typeof(Base.:(/)), var"#s185"} where var"#s185"<:Tuple{Base.SubArray{T, 1, P, I, L} where L where I where P where T, Array{T, 1} where T<:Number} where var"#s185"<:Tuple, Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dbc47240)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Nothing, var"#s185", typeof(Base.:(/)), var"#s185"} where var"#s185"<:Tuple{Base.SubArray{T, 1, P, I, L} where L where I where P where T, Array{T, 1} where T<:Number} where var"#s185"<: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=0x000000000000491c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(StaticArraysCore.missing_size_error), Type{SA} where SA<:StaticArraysCore.StaticArray{Tuple{var"#s7", var"#s8"}, Float64, 2} where var"#s7" where var"#s8"}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632df2d4060)[Core.MethodMatch(spec_types=Tuple{typeof(StaticArraysCore.missing_size_error), Type{SA} where SA<:StaticArraysCore.StaticArray{Tuple{var"#s7", var"#s8"}, Float64, 2} where var"#s7" where var"#s8"}, sparams=svec(SA<:StaticArraysCore.StaticArray{Tuple{var"#s7", var"#s8"}, Float64, 2}), method=missing_size_error(Type{SA}) where {SA}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009826, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.reindex), Any, Tuple{Int64}}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core._typeof_captured_variable), 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}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ed5fd4a0)[Core.MethodMatch(spec_types=Tuple{typeof(Core._typeof_captured_variable), 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}, 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(SolverParameters.value), SolverParameters.Parameter{T, SolverParameters.RealInterval{T}} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632eb13a8c0)[Core.MethodMatch(spec_types=Tuple{typeof(SolverParameters.value), SolverParameters.Parameter{T, SolverParameters.RealInterval{T}} where T}, sparams=svec(T), method=value(SolverParameters.Parameter{T, D} where D<:SolverParameters.AbstractDomain{T}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009860, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.widemul), Integer, Integer}, 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.BroadcastStyle, Any, Tuple{Base.RefValue{typeof(SparseMatricesCOO.replace_if_minusinf)}, AbstractArray{T, N} where N where T, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632cd81d4e0)[ 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(SparseMatricesCOO.replace_if_minusinf)}, AbstractArray{T, N} where N where T, Int64}}, 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(SparseMatricesCOO.replace_if_minusinf)}, AbstractArray{T, N} where N where T, Int64}}, 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=0x00000000000048f3, 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"#s185"} where var"#s185"<:Tuple{Int64, Array{R, 1} where R}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ca4d99c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.preprocess), Nothing, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(*)), var"#s185"} where var"#s185"<:Tuple{Int64, Array{R, 1} where R}}, 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=0x0000000000004a0e, 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.:(var"==")), Tuple{Array{Float64, 1}, Float64}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), Tuple{Array{Float64, 1}, Float64}}}}, Type{Bool}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dd04a4e0)[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.:(var"==")), Tuple{Array{Float64, 1}, Float64}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), 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=0x0000000000004915, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.__throw_rational_numerator_typemin), Type{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ed0aa260)[Core.MethodMatch(spec_types=Tuple{typeof(Base.__throw_rational_numerator_typemin), Type{Int64}}, sparams=svec(), method=__throw_rational_numerator_typemin(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003142, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.length), 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, 0x7632eaa9adc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.length), Tuple{Union{Char, Base.SubString{String}, String, Symbol}, String, String, String, Union{Char, Base.SubString{String}, String, Symbol}}}, sparams=svec(), method=length(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000068c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._newindex), Tuple{Vararg{Int64, N}} where N, Tuple{}, Tuple{}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632ca5599e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._newindex), Tuple{}, Tuple{}, Tuple{}}, sparams=svec(), method=_newindex(Tuple{}, Tuple{}, Any), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._newindex), Tuple{Vararg{Int64, N}} where N, Tuple{}, Tuple{}}, sparams=svec(), method=_newindex(Any, Tuple{}, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000049b8, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.findall), Any}, limit=3), nothing, #, #, 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, 0x7632e0063440)[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=0x0000000000003a02, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.ischunkedbroadcast), Base.BitArray{2}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.iszero)}, var"#s185"} where var"#s185"<:Tuple{Array{T, 2} where T}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632da435240)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.ischunkedbroadcast), Base.BitArray{2}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}, Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.iszero)}, var"#s185"} where var"#s185"<:Tuple{Array{T, 2} where T}}, sparams=svec(), method=ischunkedbroadcast(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a1a, 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}}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b9547860)[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}}, 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=0x00000000000048f4, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{StaticArraysCore.Size{S} where S}, LinearAlgebra.Symmetric{T, S} where S<:(StaticArraysCore.StaticArray{Tuple{var"#s7", var"#s8"}, T, 2} where var"#s8" where var"#s7") where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ab643620)[Core.MethodMatch(spec_types=Tuple{Type{StaticArraysCore.Size{S} where S}, LinearAlgebra.Symmetric{T, S} where S<:(StaticArraysCore.StaticArray{Tuple{var"#s7", var"#s8"}, T, 2} where var"#s8" where var"#s7") where T}, sparams=svec(T<:(LinearAlgebra.Symmetric{T, S} where S<:(StaticArraysCore.StaticArray{Tuple{var"#s7", var"#s8"}, T, 2} where var"#s8" where var"#s7") where T)), 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=0x0000000000009826, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), Any, FillArrays.Fill{Float64, 1, Tuple{Base.OneTo{Int64}}}, Base.Broadcast.Broadcasted{var"#s683", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s683"}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632debeeac0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.Broadcast.BroadcastStyle, FillArrays.Fill{Float64, 1, Tuple{Base.OneTo{Int64}}}, Base.Broadcast.Broadcasted{var"#s683", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s683"}, sparams=svec(), method=materialize!(Base.Broadcast.BroadcastStyle, Any, Base.Broadcast.Broadcasted{var"#s683", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s683"), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a03, 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, 0x7632e0e16ec0)[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=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.dotgetproperty), SolverCore.GenericExecutionStats{Float64, S, V, Tsp} where Tsp where V where S<:AbstractArray{Float64, 1}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b762db40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.dotgetproperty), SolverCore.GenericExecutionStats{Float64, S, V, Tsp} where Tsp where V where S<:AbstractArray{Float64, 1}, Symbol}, sparams=svec(), method=dotgetproperty(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000002a2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), Any, Any, Any, Base.RefValue{T} where T, Any, Array{T, N} where N where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632ed2afda0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Base.Broadcast.BroadcastStyle, F, Any, Base.RefValue{T} where T, 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, Any, Base.RefValue{T} where T, 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=0x0000000000004a9e, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Array{T, 1}} where T<:(QuadraticModels.Row{T} where T<:Real), UndefInitializer, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ac40baa0)[Core.MethodMatch(spec_types=Tuple{Type{Array{T, 1}} where T<:(QuadraticModels.Row{T} where T<:Real), UndefInitializer, Tuple{Int64}}, sparams=svec(T<:(QuadraticModels.Row{T} where T<:Real)), 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.Broadcast.combine_styles), LinearAlgebra.Adjoint{Float64, var"#s185"} where var"#s185"<:AbstractArray{Float64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632db2f8b00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), LinearAlgebra.Adjoint{Float64, var"#s185"} where var"#s185"<:AbstractArray{Float64, 1}}, sparams=svec(), method=combine_styles(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004972, 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"==")), var"#s185"} where var"#s185"<: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)}, Type, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632cd4aa8a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(var"==")), var"#s185"} where var"#s185"<: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)}, 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=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(var"==")), var"#s185"} where var"#s185"<: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)}, Type, Tuple{Base.OneTo{Int64}}}, sparams=svec(1, T), 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=0x0000000000004917, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.print_to_string), String, FillArrays.AbstractZeros{T, 1, Axes} where Axes where T, String, Array{R, 1} where R<:Real, String, FillArrays.AbstractZeros{T, 1, Axes} where Axes where T, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b85d8800)[Core.MethodMatch(spec_types=Tuple{typeof(Base.print_to_string), String, FillArrays.AbstractZeros{T, 1, Axes} where Axes where T, String, Array{R, 1} where R<:Real, String, FillArrays.AbstractZeros{T, 1, Axes} where Axes where T, String}, sparams=svec(), method=print_to_string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003ea0, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.min), Vararg{Any}}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.BroadcastStyle}, Type{var"#s185"} where var"#s185"<:AbstractArray{T, 1} where Float64<:T<:Real}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"##mapfoldl#275", Base._InitialValue, typeof(Base.mapfoldl), typeof(Base.identity), typeof(Base.min), 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, 0x7632eb689720)[Core.MethodMatch(spec_types=Tuple{Base.var"##mapfoldl#275", Base._InitialValue, typeof(Base.mapfoldl), typeof(Base.identity), typeof(Base.min), 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=var"#mapfoldl#275"(Any, typeof(Base.mapfoldl), Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000032da, 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##18#PreconditionerData##19"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real) where _A, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##18#PreconditionerData##19"{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, 0x7632ae7af7e0)[Core.MethodMatch(spec_types=Tuple{Type{LinearOperators.LinearOperator{_A, Int64, F, Nothing, Nothing, T}} where T where F<:(RipQP.var"#PreconditionerData##18#PreconditionerData##19"{RipQP.LDLFactorizationData{Tlow}} where Tlow<:Real) where _A, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##18#PreconditionerData##19"{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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.jacobian), Any, AbstractArray{T, 1} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632d9d79f20)[ Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.jacobian), F, StaticArraysCore.StaticArray{S, T, 1} where S<:Tuple where T} where F, sparams=svec(F<:F), method=jacobian(F, StaticArraysCore.StaticArray{S, T, N} where N where T where S<:Tuple) where {F}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.jacobian), Any, AbstractArray{T, 1} where T}, sparams=svec(F), method=jacobian(F, AbstractArray{T, N} where N where T) where {F}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009839, 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##6#PreconditionerData##7"{var"#s185"} where var"#s185"<:RipQP.FactorizationData{Tlow} where Tlow<:Real, Nothing, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632db520de0)[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##6#PreconditionerData##7"{var"#s185"} where var"#s185"<:RipQP.FactorizationData{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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.afoldl), Base.var"#promote_typeof##0#promote_typeof##1", Type{Tuple{String, Function}}, Tuple{String, typeof(JSOSolvers.R2)}, Tuple{String, typeof(JSOSolvers.fomo)}, 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, 0x7632e184af80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.afoldl), Base.var"#promote_typeof##0#promote_typeof##1", Type{Tuple{String, Function}}, Tuple{String, typeof(JSOSolvers.R2)}, Tuple{String, typeof(JSOSolvers.fomo)}, Tuple{String, Main.var"#tests##4#tests##5"{Main.var"#tests##6#tests##7"}}}, sparams=svec(), method=afoldl(Any, Any, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c1e, 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, Nothing, Tuple{Base.RefValue{typeof(RipQP.safe_boundary)}, Any}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dad4be20)[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, Nothing, Tuple{Base.RefValue{typeof(RipQP.safe_boundary)}, Any}, Nothing}, sparams=svec(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=0x00000000000048f4, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Any, ReverseDiff.TrackedArray{V, D, 1, VA, DA} where DA where VA where D where V}}, UInt64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ad04e860)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Any, ReverseDiff.TrackedArray{V, D, 1, VA, DA} where DA where VA where D where V}}, 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._count), typeof(Base.identity), Base.BitArray{N} where N, Base.Colon, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632ebb8c2a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base._count), typeof(Base.identity), Base.BitArray{N} where N, Base.Colon, Int64}, sparams=svec(), method=_count(typeof(Base.identity), Base.BitArray{N} where N, Base.Colon, Any), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000168b, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Type{LinearAlgebra.Diagonal{T, V}} where V<:Array{T, 1} where T<:Real, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dcbc8d60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Type{LinearAlgebra.Diagonal{T, V}} where V<:Array{T, 1} where T<:Real, Symbol}, sparams=svec(), method=getproperty(Type, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000299, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#overflow_case#steprange_last##0", Signed, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632df7a46e0)[Core.MethodMatch(spec_types=Tuple{Base.var"#overflow_case#steprange_last##0", Signed, Int64}, sparams=svec(), method=overflow_case(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000008a1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{LinearAlgebra.Symmetric{T, SparseMatricesCOO.SparseMatrixCOO{Tv, Ti}}} where Ti<:Integer where Tv where T, SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv, Char}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ab7062c0)[Core.MethodMatch(spec_types=Tuple{Type{LinearAlgebra.Symmetric{T, SparseMatricesCOO.SparseMatrixCOO{Tv, Ti}}}, SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti where Tv, Char} where Tv<:T where Ti<:Integer where T, sparams=svec(T, S<:(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Tv<:T where Ti<:Integer)), method=(::Type{LinearAlgebra.Symmetric{T, S}})(Any, Char) where {T, S<:(AbstractArray{var"#s4713", 2} where var"#s4713"<:T)}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000088d9, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.preprocess_args), Nothing, Tuple{Array{R, 1} where R}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bb4d0aa0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.preprocess_args), Nothing, Tuple{Array{R, 1} where R}}, sparams=svec(), method=preprocess_args(Any, Tuple{Any}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a12, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.rem), Int128, Type{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ebf6c7c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.rem), Int128, Type{Int64}}, sparams=svec(), method=rem(Int128, Type{Int64}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000b56, 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##16#PreconditionerData##17"{var"#s185"} where var"#s185"<:RipQP.FactorizationData{Tlow} where Tlow<:Real) where _A, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##16#PreconditionerData##17"{var"#s185"} where var"#s185"<: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, 0x7632ae924d20)[Core.MethodMatch(spec_types=Tuple{Type{LinearOperators.LinearOperator{_A, Int64, F, Nothing, Nothing, T}} where T where F<:(RipQP.var"#PreconditionerData##16#PreconditionerData##17"{var"#s185"} where var"#s185"<:RipQP.FactorizationData{Tlow} where Tlow<:Real) where _A, Int64, Int64, Bool, Bool, RipQP.var"#PreconditionerData##16#PreconditionerData##17"{var"#s185"} where var"#s185"<: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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.BroadcastStyle}, Type{Base.SubArray{_A, _B, P, I, true}} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632ecc43520)[ Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.BroadcastStyle}, Type{Base.SubArray{_A, _B, P, I, true}} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A}, sparams=svec(_A, _B), method=(::Type{Base.Broadcast.BroadcastStyle})(Type{var"#s683"} where var"#s683"<:AbstractArray{T, N}) where {T, N}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048dd, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._promote_typesubtract), 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, 0x7632df6f72a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._promote_typesubtract), Type{QuadraticModels.PresolvedQuadraticModel{Float64, Array{Float64, 1}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}, SparseMatricesCOO.SparseMatrixCOO{Float64, Int64}}}}, sparams=svec(), method=_promote_typesubtract(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000060e, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.collect), Base.Generator{Base.UnitRange{Int64}, F} where F<:(Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##2#__cat_offset1!##3"{Tuple{Bool, Bool}, var"#s185", 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 where var"#s185"<:Tuple)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cb1ba3c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.collect), Base.Generator{Base.UnitRange{Int64}, F} where F<:(Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##2#__cat_offset1!##3"{Tuple{Bool, Bool}, var"#s185", 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 where var"#s185"<:Tuple)}, sparams=svec(), method=collect(Base.Generator{I, F} where F where I), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001135, 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, 0x7632ba1c5460)[ 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=0x00000000000017ca, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.print), Base.GenericIOBuffer{Memory{UInt8}}, Type{Array{Union{}, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cd706560)[Core.MethodMatch(spec_types=Tuple{typeof(Base.print), Base.GenericIOBuffer{Memory{UInt8}}, Type{Array{Union{}, 1}}}, sparams=svec(), method=print(IO, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003e95, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Tuple{Tuple{Any, Int64}, Tuple{Any, Int64}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ebd57740)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Tuple{Tuple{Any, Int64}, Tuple{Any, Int64}}, Int64}, sparams=svec(), method=getindex(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000691, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s181"} where var"#s181"<:(Base.SubArray{T, N, P, I, L} where L where I where P where N where T), 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=(3,), mem=Memory{Any}(4, 0x7632b83eb120)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Base.SubArray{T, N, P, I, L} where L where I where P where N where T}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, Base.SubArray{T, N, P, I, L} where L where I where P where N where T} where T<:(Base.SubArray{T, N, P, I, L} where L where I where P where N where T), sparams=svec(T<:(AbstractArray{T, N} where N where T)), method=convert(Type{T}, T) where {T<:(AbstractArray{T, N} where N where T)}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, Base.SubArray{T, N, P, I, L} where L where I where P where N where T} where T<:(Base.SubArray{T, N, P, I, L} where L where I where P where N where T), sparams=svec(T), method=convert(Type{T}, T) where {T}, fully_covers=false), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001259, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unsafe_convert), Type{Ptr{Int32}}, Memory{Int32}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632ea1cfe20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_convert), Type{Ptr{Int32}}, Memory{Int32}}, sparams=svec(Int32), method=unsafe_convert(Type{Ptr{T}}, GenericMemory{isatomic, T, addrspace} where addrspace where T where isatomic) where {T}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000cb0, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), Base.Broadcast.DefaultArrayStyle{1}, Array{Tv, 1} where Tv, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(-)), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ea0c2400)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.Broadcast.DefaultArrayStyle{1}, Array{Tv, 1} where Tv, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(-)), var"#s185"} where var"#s185"<:Tuple{Array{R, 1} where R}}, sparams=svec(), method=materialize!(Base.Broadcast.BroadcastStyle, Any, Base.Broadcast.Broadcasted{var"#s683", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s683"), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004a03, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(var"==")), Any, Bool}, limit=3), nothing, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eltype), Type{Tuple{Int64}}}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ec9c8120)[Core.MethodMatch(spec_types=Tuple{typeof(Base.eltype), Type{Tuple{Int64}}}, sparams=svec(Int64), method=eltype(Type{var"#s185"} where var"#s185"<:Tuple{Vararg{E}}) where {E}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006cd, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IteratorEltype}, 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, 0x7632ca313dc0)[Core.MethodMatch(spec_types=Tuple{Type{Base.IteratorEltype}, 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=(::Type{Base.IteratorEltype})(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000476, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.maximum), AbstractArray{T, 1} where Float64<:T<:Real}, limit=3), nothing, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseArrays.LibSuiteSparse.cholmod_l_change_factor), Int64, Bool, Bool, Bool, Bool, SparseArrays.CHOLMOD.Factor{Float64, Int64}, Ref{SparseArrays.LibSuiteSparse.cholmod_common_struct}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632eac30760)[Core.MethodMatch(spec_types=Tuple{typeof(SparseArrays.LibSuiteSparse.cholmod_l_change_factor), Int64, Bool, Bool, Bool, Bool, SparseArrays.CHOLMOD.Factor{Float64, Int64}, 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=0x000000000000980f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.keys), NamedTuple{(:status, :solution, :objective, :dual_feas, :primal_feas, :multipliers, :multipliers_L, :multipliers_U, :iter, :elapsed_time, :solver_specific), var"#s185"} where var"#s185"<:Tuple{Symbol, Any, Real, Real, Real, Any, Any, Any, Int64, Float64, Base.Dict{Symbol, Tsp} where Tsp}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ea125660)[Core.MethodMatch(spec_types=Tuple{typeof(Base.keys), NamedTuple{(:status, :solution, :objective, :dual_feas, :primal_feas, :multipliers, :multipliers_L, :multipliers_U, :iter, :elapsed_time, :solver_specific), var"#s185"} where var"#s185"<:Tuple{Symbol, Any, Real, Real, Real, Any, Any, Any, Int64, Float64, Base.Dict{Symbol, Tsp} where Tsp}}, sparams=svec((:status, :solution, :objective, :dual_feas, :primal_feas, :multipliers, :multipliers_L, :multipliers_U, :iter, :elapsed_time, :solver_specific)), method=keys(NamedTuple{names, T} where T<:Tuple) where {names}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001af2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), Base.Broadcast.Broadcasted{var"#s185", Nothing, typeof(RipQP.safe_boundary), var"#s185"} where var"#s185"<:Tuple{AbstractArray{var"#s682", 1} where var"#s682"} where var"#s185"<:Base.Broadcast.BroadcastStyle}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632caacc7a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), Base.Broadcast.Broadcasted{var"#s185", Nothing, typeof(RipQP.safe_boundary), var"#s185"} where var"#s185"<:Tuple{AbstractArray{var"#s682", 1} where var"#s682"} where var"#s185"<: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=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004973, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), 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}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632eaa36f80)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), 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}, 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._range), Any, Int64, Nothing, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(9, 0x7632dfa73800)[ Core.MethodMatch(spec_types=Tuple{typeof(Base._range), Nothing, Int64, Nothing, Nothing}, sparams=svec(), method=_range(Nothing, Any, Nothing, Nothing), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base._range), Any, Int64, Nothing, Nothing}, sparams=svec(), method=_range(Any, Any, Nothing, Nothing), fully_covers=true), #, #, #, #, #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000087b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._any), Base.var"#TupleOrBottom##0#TupleOrBottom##1", Tuple{T, T} where T<:(Type), Base.Colon}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7632da8b49a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base._any), Base.var"#TupleOrBottom##0#TupleOrBottom##1", Tuple{T, T} where T<:(Type), Base.Colon}, sparams=svec(), method=_any(Any, Tuple, Base.Colon), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001b1e, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{StaticArrays.SOneTo{n} where n}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632eb9aa4a0)[Core.MethodMatch(spec_types=Tuple{Type{StaticArrays.SOneTo{n} where n}, Int64}, sparams=svec(), method=(::Type{StaticArrays.SOneTo{n} where n})(Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009838, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Base.Iterators.Zip{Is} where Is<:Tuple{Any, Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ec52d080)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Base.Iterators.Zip{Is} where Is<:Tuple{Any, Base.OneTo{Int64}}}, sparams=svec(), method=iterate(Base.Iterators.Zip{Is} where Is<:Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001903, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s181", var"#s185"} where var"#s185"<:Tuple{Base.RefValue{typeof(Base.:(var"=="))}, Array{T, N} where N where T, Any} where var"#s181"<:Tuple{Base.RefValue{typeof(Base.:(var"=="))}, Array{T, N} where N where T, Any}, Base.Val{3}}, limit=5), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cd110640)[Core.MethodMatch(spec_types=Tuple{typeof(Base.ntuple), Base.var"#cvt1#convert##0"{var"#s181", var"#s185"} where var"#s185"<:Tuple{Base.RefValue{typeof(Base.:(var"=="))}, Array{T, N} where N where T, Any} where var"#s181"<:Tuple{Base.RefValue{typeof(Base.:(var"=="))}, Array{T, N} where N where T, Any}, Base.Val{3}}, sparams=svec(), method=ntuple(Any, Base.Val{3}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000181c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.CanonicalIndexError}, String, Type{Array{Tv, 1}} where Tv<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dd026be0)[Core.MethodMatch(spec_types=Tuple{Type{Base.CanonicalIndexError}, String, Type{Array{Tv, 1}} where Tv<:Real}, sparams=svec(), method=(::Type{Base.CanonicalIndexError})(String, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001316, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.min), Int128, Any}, limit=3), nothing, #, #, #, #, #, #, 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, 0x7632db5f5220)[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"#s683", Axes, F, Args} where var"#s683") where {NewStyle, Axes, F, Args}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004913, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_typejoin_union), Type{Symbol}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632dc528720)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_typejoin_union), Type{Symbol}}, sparams=svec(Symbol), method=promote_typejoin_union(Type{T}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000610, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.typeintersect), Type{Tuple{Any, Any, Any}}, Type{var"#s181"} where var"#s181"<:Tuple{Base.RefValue{typeof(Base.min)}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e1ad9d00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.typeintersect), Type{Tuple{Any, Any, Any}}, Type{var"#s181"} where var"#s181"<:Tuple{Base.RefValue{typeof(Base.min)}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T}}, sparams=svec(), method=typeintersect(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000547, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Union{}}, Float16}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632da27c3e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Float16}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000036c, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core._typeof_captured_variable), Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e07e5420)[Core.MethodMatch(spec_types=Tuple{typeof(Core._typeof_captured_variable), Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, 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{Type{Base.SubArray{T, N, P, I, L} where L where I where P where N where T}, Base.IndexCartesian, Array{Float64, 1}, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, Tuple{Bool}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632ca382740)[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, Array{Float64, 1}, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, Tuple{Bool}}, sparams=svec(Array{Float64, 1}, Tuple{Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, 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=0x0000000000002e44, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), var"#s185"} where var"#s185"<:Tuple{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.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, 0x7632dc6e7c60)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:S,), var"#s185"} where var"#s185"<:Tuple{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.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(Tlow<: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=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.typeintersect), Type{Tuple{Any, Any, Any}}, Type{var"#s181"} where var"#s181"<:Tuple{Base.RefValue{typeof(Base.:(*))}, AbstractArray{Float64, 1}, Array{Float64, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b92f4fa0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.typeintersect), Type{Tuple{Any, Any, Any}}, Type{var"#s181"} where var"#s181"<:Tuple{Base.RefValue{typeof(Base.:(*))}, AbstractArray{Float64, 1}, Array{Float64, 1}}}, sparams=svec(), method=typeintersect(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000547, 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, 0x7632de937480)[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(RipQP.convert_mat), Any, Type{T} where T<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7632cba539a0)[ Core.MethodMatch(spec_types=Tuple{typeof(RipQP.convert_mat), Union{SparseArrays.SparseMatrixCSC{Tv, Ti} where Ti<:Integer where Tv, SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv}, Type{T}} where T<:Real, sparams=svec(T<:Real), method=convert_mat(Union{SparseArrays.SparseMatrixCSC{Tv, Ti} where Ti<:Integer where Tv, SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv}, Type{T}) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(RipQP.convert_mat), Array{T, 2} where T, Type{T}} where T<:Real, sparams=svec(T<:Real), method=convert_mat(Array{T, 2} where T, Type{T}) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009906, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.RefValue{typeof(Base.:(<))}, Any, Float64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b7001200)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.RefValue{typeof(Base.:(<))}, Any, 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{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, 0x7632bb94f640)[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=0x00000000000048f4, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Iterators._zip_iterate_some), Tuple{AbstractArray{typeof(DataType), 1}}, Tuple{Tuple{Any}}, Tuple{Base.Missing}, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bb5b6980)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators._zip_iterate_some), Tuple{AbstractArray{typeof(DataType), 1}}, Tuple{Tuple{Any}}, 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=0x0000000000001909, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s181"} where var"#s181"<:(Union{AbstractArray{_A, 2}, LinearOperators.LinearOperator{_A, I, F, Ft, Fct, S} where S where Fct where Ft where F where I<:Integer} where _A<:Real), Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.typeintersect), Type{NTuple{4, Any}}, Type{var"#s181"} where var"#s181"<:Tuple{Any, Base.RefValue{T} where T, AbstractArray{Float64, 1}, Array{Float64, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b9585b20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.typeintersect), Type{NTuple{4, Any}}, Type{var"#s181"} where var"#s181"<:Tuple{Any, Base.RefValue{T} where T, AbstractArray{Float64, 1}, Array{Float64, 1}}}, sparams=svec(), method=typeintersect(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000547, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.structdiff), NamedTuple{(:mode, :display), Tuple{Symbol, Bool}}, Type{NamedTuple{(:ps, :scaling, :history, :display), T} where T<:Tuple}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632cbc76000)[Core.MethodMatch(spec_types=Tuple{typeof(Base.structdiff), NamedTuple{(:mode, :display), Tuple{Symbol, Bool}}, Type{NamedTuple{(:ps, :scaling, :history, :display), T} where T<:Tuple}}, sparams=svec((:mode, :display), (:ps, :scaling, :history, :display)), method=structdiff(NamedTuple{an, T} where T<:Tuple, Union{Type{NamedTuple{bn, T} where T<:Tuple}, NamedTuple{bn, T} where T<:Tuple}) where {an, bn}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001b06, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#cvt1#convert##0"{var"#s181", var"#s185"} where var"#s185"<: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)} where var"#s181"<: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)}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e19a5e00)[Core.MethodMatch(spec_types=Tuple{Base.var"#cvt1#convert##0"{var"#s181", var"#s185"} where var"#s185"<: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)} where var"#s181"<: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)}, Int64}, sparams=svec(var"#s181"<: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)}), method=(::Base.var"#cvt1#convert##0"{T, x})(Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000398, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{FillArrays.Fill{Float64, 1, Axes} where Axes}, Float64, Tuple{Base.OneTo{T} where T<:Integer}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632e02c5140)[Core.MethodMatch(spec_types=Tuple{Type{FillArrays.Fill{Float64, 1, Axes} where Axes}, Float64, Tuple{Base.OneTo{T} where T<:Integer}}, sparams=svec(Float64, 1, Axes<:Tuple{Base.OneTo{T} where T<:Integer}), 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=0x000000000000981b, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._promote_typesubtract), Type{Float32}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632b6f008a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._promote_typesubtract), Type{Float32}}, sparams=svec(), method=_promote_typesubtract(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000060e, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.nbitslen), Type{Float16}, Any, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632bb355960)[Core.MethodMatch(spec_types=Tuple{typeof(Base.nbitslen), Type{Float16}, Any, Any}, sparams=svec(Float16), method=nbitslen(Type{T}, Any, Any) where {T<:Union{Float16, Float32, Float64}}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002fa5, 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"#s185"} where var"#s185"<:RipQP.FactorizationData{Tlow} where Tlow<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7632eac2cdc0)[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"#s185"} where var"#s185"<:RipQP.FactorizationData{Tlow} where Tlow<:Real}, 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) where {T, I<:Integer}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009848, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s181"} where var"#s181"<:(FillArrays.Fill{T, N, Axes} where Axes where N where T), FillArrays.Fill{T, N, Axes} where Axes where N where T}, limit=3), nothing, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.newindex), Any, Tuple{}, Tuple{}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7632ca39b420)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.newindex), Base.IteratorsMD.CartesianIndex{1}, Tuple{}, Tuple{}}, sparams=svec(), method=newindex(Base.IteratorsMD.CartesianIndex{1}, Any, Any), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.newindex), Base.IteratorsMD.CartesianIndex{N} where N, Tuple{}, Tuple{}}, sparams=svec(), method=newindex(Base.IteratorsMD.CartesianIndex{N} where N, Any, Any), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.newindex), Integer, Tuple{}, Tuple{}}, sparams=svec(), method=newindex(Integer, Tuple{}, Any), fully_covers=false), #]), valid_worlds=Base.Compiler.WorldRange(min_w PkgEval terminated after 899.2s: test log exceeded the size limit