Package evaluation of CaNNOLeS on Julia 1.12.0-rc1.2 (995ff9db19*) started at 2025-07-14T17:25:30.832 ################################################################################ # Set-up # Installing PkgEval dependencies (TestEnv)... Set-up completed after 9.61s ################################################################################ # Installation # Installing CaNNOLeS... Resolving package versions... Updating `~/.julia/environments/v1.12/Project.toml` [5a1c9e79] + CaNNOLeS v0.8.0 Updating `~/.julia/environments/v1.12/Manifest.toml` [14f7f29c] + AMD v0.5.3 [66dad0bd] + AliasTables v1.1.3 [5a1c9e79] + CaNNOLeS v0.8.0 [35d6a980] + ColorSchemes v3.30.0 [3da002f7] + ColorTypes v0.12.1 [c3611d14] + ColorVectorSpace v0.11.0 [5ae59095] + Colors v0.13.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 [ffbed154] + DocStringExtensions v0.9.5 [e2ba6199] + ExprTools v0.1.10 [9aa1b823] + FastClosures v0.3.2 [53c48c17] + FixedPointNumbers v0.8.5 [34c5aeac] + HSL v0.5.1 [92d709cd] + IrrationalConstants v0.2.4 [692b3bcd] + JLLWrappers v1.7.0 [ba0b0d4f] + Krylov v0.10.1 [40e66cde] + LDLFactorizations v0.10.1 [5c8ed15e] + LinearOperators v2.10.0 [2ab3a3ac] + LogExpFunctions v0.3.29 [299715c1] + MarchingCubes v0.1.11 [e1d29d7a] + Missings v1.2.0 [a4795742] + NLPModels v0.21.5 [77ba4419] + NaNMath v1.1.3 [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 [189a3867] + Reexport v1.2.2 [ae029012] + Requires v1.3.1 [ff4d7338] + SolverCore v0.3.8 [a2af1166] + SortingAlgorithms v1.2.1 [fa32481b] + SparseMatricesCOO v0.2.4 [90137ffa] + StaticArrays v1.9.13 [1e83bf80] + StaticArraysCore v1.4.3 [10745b16] + Statistics v1.11.1 [82ae8749] + StatsAPI v1.7.1 [2913bbd2] + StatsBase v0.34.5 [62fd8b95] + TensorCore v0.1.1 [a759f4b9] + TimerOutputs v0.5.29 [b8865327] + UnicodePlots v3.8.1 [017b0a0e] + HSL_jll v4.0.2+0 [656ef2d0] + OpenBLAS32_jll v0.3.29+0 [56f22d72] + Artifacts v1.11.0 [2a0f44e3] + Base64 v1.11.0 [ade2ca70] + Dates v1.11.0 [b77e0a4c] + InteractiveUtils v1.11.0 [ac6e5ff7] + JuliaSyntaxHighlighting v1.12.0 [8f399da3] + Libdl v1.11.0 [37e2e46d] + LinearAlgebra v1.12.0 [56ddb016] + Logging v1.11.0 [d6f4376e] + Markdown v1.11.0 [de0858da] + Printf v1.11.0 [9a3f8284] + Random v1.11.0 [ea8e919c] + SHA v0.7.0 [9e88b42a] + Serialization v1.11.0 [2f01184e] + SparseArrays v1.12.0 [f489334b] + StyledStrings v1.11.0 [fa267f1f] + TOML v1.0.3 [8dfed614] + Test v1.11.0 [cf7118a7] + UUIDs v1.11.0 [4ec0a83e] + Unicode v1.11.0 [e66e0078] + CompilerSupportLibraries_jll v1.3.0+1 [4536629a] + OpenBLAS_jll v0.3.29+0 [05823500] + OpenLibm_jll v0.8.5+0 [bea87d4a] + SuiteSparse_jll v7.8.3+2 [8e850b90] + libblastrampoline_jll v5.13.1+0 Installation completed after 4.39s ################################################################################ # Precompilation # Precompiling PkgEval dependencies... Precompiling package dependencies... Precompilation completed after 29.58s ################################################################################ # Testing # Testing CaNNOLeS Status `/tmp/jl_VVma3Y/Project.toml` [54578032] ADNLPModels v0.8.12 [5a1c9e79] CaNNOLeS v0.8.0 [34c5aeac] HSL v0.5.1 [a4795742] NLPModels v0.21.5 [ff4d7338] SolverCore v0.3.8 [56ddb016] Logging v1.11.0 [8dfed614] Test v1.11.0 Status `/tmp/jl_VVma3Y/Manifest.toml` [54578032] ADNLPModels v0.8.12 [47edcb42] ADTypes v1.15.0 [14f7f29c] AMD v0.5.3 [66dad0bd] AliasTables v1.1.3 [5a1c9e79] CaNNOLeS v0.8.0 [d360d2e6] ChainRulesCore v1.25.2 [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 [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 [ba0b0d4f] Krylov v0.10.1 [40e66cde] LDLFactorizations v0.10.1 [5c8ed15e] LinearOperators v2.10.0 [2ab3a3ac] LogExpFunctions v0.3.29 [1914dd2f] MacroTools v0.5.16 [299715c1] MarchingCubes v0.1.11 [e1d29d7a] Missings v1.2.0 [a4795742] NLPModels v0.21.5 [77ba4419] NaNMath v1.1.3 [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 [189a3867] Reexport v1.2.2 [ae029012] Requires v1.3.1 [37e2e3b7] ReverseDiff v1.16.1 [ff4d7338] SolverCore v0.3.8 [a2af1166] SortingAlgorithms v1.2.1 [9f842d2f] SparseConnectivityTracer v0.6.21 [fa32481b] SparseMatricesCOO v0.2.4 [0a514795] SparseMatrixColorings v0.4.21 [276daf66] SpecialFunctions v2.5.1 [90137ffa] StaticArrays v1.9.13 [1e83bf80] StaticArraysCore v1.4.3 [10745b16] Statistics v1.11.1 [82ae8749] StatsAPI v1.7.1 [2913bbd2] StatsBase v0.34.5 [62fd8b95] TensorCore v0.1.1 [a759f4b9] TimerOutputs v0.5.29 [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 [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 [fa267f1f] TOML v1.0.3 [8dfed614] Test v1.11.0 [cf7118a7] UUIDs v1.11.0 [4ec0a83e] Unicode v1.11.0 [e66e0078] CompilerSupportLibraries_jll v1.3.0+1 [4536629a] OpenBLAS_jll v0.3.29+0 [05823500] OpenLibm_jll v0.8.5+0 [bea87d4a] SuiteSparse_jll v7.8.3+2 [8e850b90] libblastrampoline_jll v5.13.1+0 Testing Running tests... Precompiling packages... 6066.9 ms ✓ StatsBase 108415.4 ms ✓ UnicodePlots 9483.2 ms ✓ SparseMatricesCOO 9764.6 ms ✓ CaNNOLeS 4 dependencies successfully precompiled in 135 seconds. 65 already precompiled. 1 dependency had output during precompilation: ┌ SparseMatricesCOO │ WARNING: Constructor for type "Matrix" was extended in `SparseMatricesCOO` without explicit qualification or import. │ NOTE: Assumed "Matrix" refers to `Base.Matrix`. This behavior is deprecated and may differ in future versions.` │ NOTE: This behavior may have differed in Julia versions prior to 1.12. │ Hint: If you intended to create a new generic function of the same name, use `function Matrix end`. │ Hint: To silence the warning, qualify `Matrix` as `Base.Matrix` in the method signature or explicitly `import Base: Matrix`. │ WARNING: Constructor for type "Array" was extended in `SparseMatricesCOO` without explicit qualification or import. │ NOTE: Assumed "Array" refers to `Base.Array`. This behavior is deprecated and may differ in future versions.` │ NOTE: This behavior may have differed in Julia versions prior to 1.12. │ Hint: If you intended to create a new generic function of the same name, use `function Array end`. │ Hint: To silence the warning, qualify `Array` as `Base.Array` in the method signature or explicitly `import Base: Array`. └ Precompiling packages... 2890.2 ms ✓ SparseMatrixColorings → SparseMatrixColoringsColorsExt 1 dependency successfully precompiled in 3 seconds. 18 already precompiled. Precompiling packages... 1836.7 ms ✓ ColorVectorSpace → SpecialFunctionsExt 1 dependency successfully precompiled in 2 seconds. 20 already precompiled. #= /home/pkgeval/.julia/packages/CaNNOLeS/XBbAl/test/runtests.jl:34 =# @allocated(solve!(solver, nls, stats)) = 0 Test Summary: | Pass Total Time Test allocations CaNNOLeS | 1 1 33.0s #= /home/pkgeval/.julia/packages/CaNNOLeS/XBbAl/test/runtests.jl:34 =# @allocated(solve!(solver, nls, stats)) = 0 Test Summary: | Pass Total Time Test allocations CaNNOLeS | 1 1 0.0s ┌ Warning: linsolve ma57 not available. Using :ldlfactorizations instead └ @ CaNNOLeS ~/.julia/packages/CaNNOLeS/XBbAl/src/CaNNOLeS.jl:318 Test Summary: | Pass Total Time Test callback | 1 1 32.9s Test Summary: | Pass Total Time Re-solve with a different initial guess | 4 4 25.6s Test Summary: | Pass Total Time Small residual stop | 4 4 25.2s Test Summary: | Pass Total Time Re-solve with a different problem | 4 4 20.1s ┌ Warning: linsolve ma57 not available. Using :ldlfactorizations instead └ @ CaNNOLeS ~/.julia/packages/CaNNOLeS/XBbAl/src/CaNNOLeS.jl:318 ┌ Warning: linsolve ma57 not available. Using :ldlfactorizations instead └ @ CaNNOLeS ~/.julia/packages/CaNNOLeS/XBbAl/src/CaNNOLeS.jl:318 Test Summary: | Pass Total Time Problem without second order information can be solved with method=:Newton_noFHess | 3 3 20.5s Internal error: during type inference of cannoles_tests() Encountered unexpected error in runtime: MethodError(f=Base.Compiler.abstract_eval_basic_statement, args=(Base.Compiler.NativeInterpreter(world=0x0000000000009785, method_table=Base.Compiler.CachedMethodTable{Base.Compiler.InternalMethodTable}(cache=Base.IdDict{Base.Compiler.MethodMatchKey, Union{Nothing, Base.Compiler.MethodLookupResult}}(ht=Memory{Any}(32768, 0x5c3e700)[ Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IteratorEltype}, ColorTypes.ComponentIterator{C} where C<:(Union{ColorTypes.AlphaColor{Cb, T, N} where N where T, ColorTypes.ColorAlpha{Cb, T, N} where N where T, Cb} where Cb<:Union{ColorTypes.HSI{T} where T<:AbstractFloat, ColorTypes.HSL{T} where T<:AbstractFloat, ColorTypes.HSV{T} where T<:AbstractFloat, ColorTypes.LCHab{T} where T<:AbstractFloat, ColorTypes.LCHuv{T} where T<:AbstractFloat, ColorTypes.Oklch{T} where T<:AbstractFloat})}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bec77960)[Core.MethodMatch(spec_types=Tuple{Type{Base.IteratorEltype}, ColorTypes.ComponentIterator{C} where C<:(Union{ColorTypes.AlphaColor{Cb, T, N} where N where T, ColorTypes.ColorAlpha{Cb, T, N} where N where T, Cb} where Cb<:Union{ColorTypes.HSI{T} where T<:AbstractFloat, ColorTypes.HSL{T} where T<:AbstractFloat, ColorTypes.HSV{T} where T<:AbstractFloat, ColorTypes.LCHab{T} where T<:AbstractFloat, ColorTypes.LCHuv{T} where T<:AbstractFloat, ColorTypes.Oklch{T} where T<:AbstractFloat})}, sparams=svec(), method=(::Type{Base.IteratorEltype})(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000456, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Any, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb936900)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A} where N where V where T, sparams=svec(T, V, N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any) where {T, V, N}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, 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.:(var"==")), Tuple{Array{Float16, 1}, Float16}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c9bb4b40)[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.:(var"==")), Tuple{Array{Float16, 1}, Float16}, Nothing}, sparams=svec(typeof(Base.:(var"=="))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(DiffResults.value!), ForwardDiff.var"#extract_value!##0#extract_value!##1"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), DiffResults.DiffResult{O, V, D} where D<:Tuple where V where O, AbstractArray{T, N} where N where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c1a69160)[ Core.MethodMatch(spec_types=Tuple{typeof(DiffResults.value!), ForwardDiff.var"#extract_value!##0#extract_value!##1"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), DiffResults.MutableDiffResult{O, V, D} where D<:Tuple where V where O, AbstractArray{T, N} where N where T}, sparams=svec(), method=value!(Any, DiffResults.MutableDiffResult{O, V, D} where D<:Tuple where V where O, AbstractArray{T, N} where N where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(DiffResults.value!), ForwardDiff.var"#extract_value!##0#extract_value!##1"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), DiffResults.ImmutableDiffResult{O, V, D} where D<:Tuple, AbstractArray{T, N} where N where T} where V where O, sparams=svec(O, V), method=value!(Any, DiffResults.ImmutableDiffResult{O, V, D} where D<:Tuple, AbstractArray{T, N} where N where T) where {O, V}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009687, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, _A, var"#s179"} where var"#s179"<:Tuple where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94ce6b4e60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, _A, var"#s179"} where var"#s179"<:Tuple where _A}, sparams=svec(), method=instantiate(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004803, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{ReverseDiff.JacobianConfig{I, O} where O where I}, Array{Float16, 1}, Type{Float16}, Array{ReverseDiff.AbstractInstruction, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c8fd5840)[Core.MethodMatch(spec_types=Tuple{Type{ReverseDiff.JacobianConfig{I, O} where O where I}, Array{Float16, 1}, Type{Float16}, Array{ReverseDiff.AbstractInstruction, 1}}, sparams=svec(), method=(::Type{ReverseDiff.JacobianConfig{I, O} where O where I})(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), SparseArrays.SparseMatrixCSC{Float16, Ti} where Ti<:Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c7d538a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), SparseArrays.SparseMatrixCSC{Float16, Ti} where Ti<:Integer}, sparams=svec(), method=size(Union{SparseArrays.FixedSparseCSC{Tv, Ti} where Ti<:Integer where Tv, SparseArrays.SparseMatrixCSC{Tv, Ti} where Ti<:Integer where Tv}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009678, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IndexStyle}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.isnan), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bf74ba40)[Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.isnan), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{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=0x00000000000047e9, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.check_broadcast_axes), Tuple, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb8a8380)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.check_broadcast_axes), Tuple, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(), method=check_broadcast_axes(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004864, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Int64}, UInt32}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c8b6d660)[Core.MethodMatch(spec_types=Tuple{Type{Int64}, UInt32}, sparams=svec(), method=(::Type{Int64})(Union{Bool, Int128, Int16, Int32, Int64, Int8, UInt128, UInt16, UInt32, UInt64, UInt8}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000217, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Array{Int64, 1}}, UndefInitializer, Any}, 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}}, Nothing, typeof(Base.:(+)), Tuple{Base.Broadcast.Extruded{Array{Float64, 1}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{Base.SubArray{Float64, 1, Array{Float64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{Bool}, Tuple{Int64}}}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c3f8c340)[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{Array{Float64, 1}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{Base.SubArray{Float64, 1, Array{Float64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{Bool}, Tuple{Int64}}}, Tuple{Base.OneTo{Int64}}}, sparams=svec(typeof(Base.:(+))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Type{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ce06d800)[Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Type{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}}}, sparams=svec(ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}), method=similar(Array{T, 1}, Type) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010b5, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{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{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0b1ece0)[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{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}}, 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) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isvarargtype), Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ccf5f0a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.isvarargtype), Any}, sparams=svec(), method=isvarargtype(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000369, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.BroadcastStyle}, Type{Tuple{Array{Float16, 1}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c33aaaa0)[ Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.BroadcastStyle}, Type{Tuple{Array{Float16, 1}}}}, sparams=svec(), method=(::Type{Base.Broadcast.BroadcastStyle})(Type{var"#s677"} where var"#s677"<:Tuple), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000478d, 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}, _A}} where _A)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c1f78d80)[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}, _A}} 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=0x000000000000042b, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{ForwardDiff.HessianConfig{T, V, N, DG, DJ} where DJ where DG where N where V where T}, ForwardDiff.JacobianConfig{T, Float16, _A, Array{ForwardDiff.Dual{T, Float16, _A}, 1}} where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), ForwardDiff.GradientConfig{T, V, _A, Array{ForwardDiff.Dual{T, V, _A}, 1}} where _A where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A) where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A) where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F))}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c3f28ee0)[Core.MethodMatch(spec_types=Tuple{Type{ForwardDiff.HessianConfig{T, V, N, DG, DJ} where DJ where DG where N where V where T}, ForwardDiff.JacobianConfig{T, Float16, N, Array{ForwardDiff.Dual{T, Float16, _A}, 1}}, ForwardDiff.GradientConfig{T, ForwardDiff.Dual{T, Float16, N}, N, Array{ForwardDiff.Dual{T, V, _A}, 1}}} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A) where _A where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), Float16, N, DG<:(Array{ForwardDiff.Dual{T, V, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A) where _A), DJ<:(Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A)), method=(::Type{ForwardDiff.HessianConfig{T, V, N, DG, DJ} where DJ where DG where N where V where T})(ForwardDiff.JacobianConfig{T, V, N, DJ}, ForwardDiff.GradientConfig{T, ForwardDiff.Dual{T, V, N}, N, DG}) where {T, V, N, DG, DJ}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(FillArrays._fill_getindex), FillArrays.AbstractFill{T, 1, Axes} where Axes where T, Array{Int64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c055c540)[Core.MethodMatch(spec_types=Tuple{typeof(FillArrays._fill_getindex), FillArrays.AbstractFill{T, 1, Axes} where Axes where T, Array{Int64, 1}}, sparams=svec(1), method=_fill_getindex(FillArrays.AbstractFill{T, N, Axes} where Axes where N where T, Vararg{Union{Real, AbstractArray{T, N} where N where T}, N}) where {N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000967a, 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!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{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, 0x7f94cf4e4480)[Core.MethodMatch(spec_types=Tuple{typeof(Base._simple_count), typeof(Base.identity), Base.Generator{Array{Int64, 1}, F} where F<:(NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{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=0x00000000000032c5, 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{Float16, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cef1b640)[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{Float16, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}}}, sparams=svec(Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(*)), Tuple{Float16, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}), method=convert(Type{Base.Broadcast.Broadcasted{NewStyle, Axes, F, Args} where Args<:Tuple where F where Axes}, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where var"#s677") where {NewStyle, Axes, F, Args}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047d1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.min), Any, Int64}, limit=3), nothing, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.summary), Array{Ti, 1} where Ti<:Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ce62da00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.summary), Array{Ti, 1} where Ti<:Integer}, sparams=svec(), method=summary(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004445, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.maybeview), Array{Float16, 1}, Array{Ti, 1} where Ti<:Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94bf5c2b60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.maybeview), Array{Float16, 1}, Array{Ti, 1} where Ti<:Integer}, sparams=svec(), method=maybeview(AbstractArray{T, N} where N where T, Any...), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002e4e, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), ForwardDiff.var"#partials_wrap#extract_jacobian_chunk!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)), Any, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94ff166d20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), ForwardDiff.var"#partials_wrap#extract_jacobian_chunk!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)), Any, Any}, sparams=svec(F<:(ForwardDiff.var"#partials_wrap#extract_jacobian_chunk!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)))), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004959, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IndexStyle}, Array{ForwardDiff.Dual{Nothing, Float16, N}, 1} where N, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c1aebea0)[Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Array{ForwardDiff.Dual{Nothing, Float16, N}, 1} where N, Array{Float16, 1}}, sparams=svec(), method=(::Type{Base.IndexStyle})(AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000fa9, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ADNLPModels.sparse_hess_coord!), ADNLPModels.SparseReverseADHessian{Tagf, Tagψ, R, T, C, H, S, F, P} where P where F where S where H where C where T where R where Tagψ where Tagf, Array{Float16, 1}, Float16, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0b9e560)[Core.MethodMatch(spec_types=Tuple{typeof(ADNLPModels.sparse_hess_coord!), ADNLPModels.SparseReverseADHessian{Tagf, Tagψ, R, T, C, H, S, F, P} where P where F where S where H where C where T where R where Tagψ where Tagf, Array{Float16, 1}, Float16, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(Tagf, Tagψ), method=sparse_hess_coord!(ADNLPModels.SparseReverseADHessian{Tagf, Tagψ, R, T, C, H, S, F, P} where P where F where S where H where C where T where R, AbstractArray{T, 1} where T, Any, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T) where {Tagf, Tagψ}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ad, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.resize!), Array{Float16, 1}, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c8aff5a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.resize!), Array{Float16, 1}, Integer}, sparams=svec(), method=resize!(Array{T, 1} where T, Integer), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001159, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Style, Nothing, F, Args} where Args<:Tuple where F where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(∘)), 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.ADNLSModel{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, 0x7f94ce083720)[Core.MethodMatch(spec_types=Tuple{typeof(Base.:(∘)), 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.ADNLSModel{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=∘(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c39, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Array{Float16, 2}, Tuple{Base.UnitRange{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bf08f6a0)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Array{Float16, 2}, Tuple{Base.UnitRange{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.diff_names), Tuple{Vararg{Symbol}}, Tuple{Symbol}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb937940)[Core.MethodMatch(spec_types=Tuple{typeof(Base.diff_names), Tuple{Vararg{Symbol}}, Tuple{Symbol}}, sparams=svec(), method=diff_names(Tuple{Vararg{Symbol}}, Tuple{Vararg{Symbol}}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001aaf, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ReverseDiff.seeded_reverse_pass!), Array{Float16, 2}, ReverseDiff.JacobianTape{F, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, _A} where _A where F<:Function}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bf1364e0)[Core.MethodMatch(spec_types=Tuple{typeof(ReverseDiff.seeded_reverse_pass!), Array{Float16, 2}, ReverseDiff.JacobianTape{F, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, _A} where _A where F<:Function}, sparams=svec(), method=seeded_reverse_pass!(Any, ReverseDiff.AbstractTape), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), Array{ForwardDiff.Dual{Tagψ, T, 1}, 1} where T where Tagψ, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.identity), Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cf7d5fe0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), Array{ForwardDiff.Dual{Tagψ, T, 1}, 1} where T where Tagψ, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.identity), Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}}}, sparams=svec(), method=combine_styles(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004832, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.LinearIndices{N, R} where R<:Tuple{Vararg{Base.AbstractUnitRange{Int64}, N}} where N}, Memory{Float16}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cde8c520)[Core.MethodMatch(spec_types=Tuple{Type{Base.LinearIndices{N, R} where R<:Tuple{Vararg{Base.AbstractUnitRange{Int64}, N}} where N}, Memory{Float16}}, sparams=svec(), method=(::Type{Base.LinearIndices{N, R} where R<:Tuple{Vararg{Base.AbstractUnitRange{Int64}, N}} where N})(Union{Core.SimpleVector, AbstractArray{T, N} where N where T}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001017, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c26922e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Int64}, sparams=svec(1), method=getindex(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Vararg{Union{Integer, Base.IteratorsMD.CartesianIndex{N} where N}, N}) where {N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000487c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.transpose), Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{ForwardDiff.var"#hessian##0#hessian##1"{ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}}, ForwardDiff.HessianConfig{T, V, N, DG, DJ}} where DJ where DG where N where V where T where F, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c47df1c0)[Core.MethodMatch(spec_types=Tuple{ForwardDiff.var"#hessian##0#hessian##1"{ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}}, ForwardDiff.HessianConfig{T, V, N, DG, DJ}} where DJ where DG where N where V where T where F, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A}, sparams=svec(), method=(::ForwardDiff.var"#hessian##0#hessian##1"{f, cfg})(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ADNLPModels.sparse_hess_coord!), ADNLPModels.SparseADHessian{Tag, R, T, C, H, S, GT} where GT where S where H where C where T where R where Tag, Array{Float16, 1}, Float16, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0b9df80)[Core.MethodMatch(spec_types=Tuple{typeof(ADNLPModels.sparse_hess_coord!), ADNLPModels.SparseADHessian{Tag, R, T, C, H, S, GT} where GT where S where H where C where T where R where Tag, Array{Float16, 1}, Float16, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(Tag), method=sparse_hess_coord!(ADNLPModels.SparseADHessian{Tag, R, T, C, H, S, GT} where GT where S where H where C where T where R, AbstractArray{T, 1} where T, Any, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T) where {Tag}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ad, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Any, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A, Any, Tuple{Vararg{ForwardDiff.Partials{N, ForwardDiff.Dual{T, V, N}}, N}} where N where V where T, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0a47f20)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), AbstractArray{ForwardDiff.Dual{T, ForwardDiff.Dual{T, V, N}, N}, N} where N, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A, Any, Tuple{Vararg{ForwardDiff.Partials{N, ForwardDiff.Dual{T, V, N}}, N}}, Any} where N where T where V where T, sparams=svec(T, V<:(ForwardDiff.Dual{T, V, N} where T where V where N), N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any, Tuple{Vararg{ForwardDiff.Partials{N, V}, N}}, Any) where {T, V, N}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, 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{Float16, 1}, Float16}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cee152c0)[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{Float16, 1}, Float16}, Nothing}, sparams=svec(typeof(Base.:(<))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Array{Float16, 1}, Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c0bbee60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Array{Float16, 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{Float16, 1}, Integer}, sparams=svec(), method=getindex(Array{T, N} where N where T, Integer, Integer...), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012d2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Generator{I, F} where F where I}, Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##0#__cat_offset1!##1"{Tuple{Int64}, Tuple{Bool}, Tuple{Int64}, Tuple{Main.var"#F_Rosen#cannoles_tests##1", Array{Float64, 1}, Array{Float64, 1}}}}, Base.UnitRange{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c9106720)[Core.MethodMatch(spec_types=Tuple{Type{Base.Generator{I, F} where F where I}, Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##0#__cat_offset1!##1"{Tuple{Int64}, Tuple{Bool}, Tuple{Int64}, Tuple{Main.var"#F_Rosen#cannoles_tests##1", Array{Float64, 1}, Array{Float64, 1}}}}, Base.UnitRange{Int64}}, sparams=svec(Base.UnitRange{Int64}, Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##0#__cat_offset1!##1"{Tuple{Int64}, Tuple{Bool}, Tuple{Int64}, Tuple{Main.var"#F_Rosen#cannoles_tests##1", Array{Float64, 1}, Array{Float64, 1}}}}), method=(::Type{Base.Generator{I, F} where F where I})(F, I) where {I, F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000420, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:x, :verbose), Tuple{Array{Float16, 1}, Int64}}, typeof(SolverCore.solve!), CaNNOLeS.CaNNOLeSSolver{Ti, Float16, Array{Float16, 1}, CaNNOLeS.MA57Struct, _A} where _A where Ti<:Integer, ADNLPModels.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ff1e7c00)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:x, :verbose), Tuple{Array{Float16, 1}, Int64}}, typeof(SolverCore.solve!), CaNNOLeS.CaNNOLeSSolver{Ti, Float16, Array{Float16, 1}, CaNNOLeS.MA57Struct, _A} where _A where Ti<:Integer, ADNLPModels.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}}, sparams=svec(), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(SolverCore.solve!), SolverCore.AbstractOptimizationSolver, NLPModels.AbstractNLPModel{T, S} where S where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096b2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{NLPModels.DimensionError}, String, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cc9ee040)[Core.MethodMatch(spec_types=Tuple{Type{NLPModels.DimensionError}, String, Int64, Int64}, sparams=svec(), method=(::Type{NLPModels.DimensionError})(Union{String, Symbol}, Int64, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096aa, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Tuple{typeof(DataType), Type}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fcda3760)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Tuple{typeof(DataType), Type}}, sparams=svec(), method=iterate(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000067a, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(+)), Int64, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94ffe00060)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(+)), Int64, Any}, sparams=svec(typeof(Base.:(+))), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004959, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.zero), Type{Float16}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c95bd720)[Core.MethodMatch(spec_types=Tuple{typeof(Base.zero), Type{Float16}}, sparams=svec(Float16), method=zero(Type{T}) where {T<:Number}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000a7c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.IteratorsMD.CartesianIndex{N} where N, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c9df82c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.IteratorsMD.CartesianIndex{N} where N, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.throwdm), Tuple, Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c255eac0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.throwdm), Tuple, Tuple}, sparams=svec(), method=throwdm(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048ed, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N where N where V where T, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A, Any, ForwardDiff.Partials{N, V} where V where N}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0a1eec0)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A, Any, ForwardDiff.Partials{N, V}} where N where V where T, sparams=svec(T, V, N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any, ForwardDiff.Partials{N, V}) where {T, V, N}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, 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{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{Bool}, Tuple{Int64}}}, Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb405de0)[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{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{Bool}, Tuple{Int64}}}, Tuple}, sparams=svec(typeof(Base.identity)), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{SolverCore.var"##solve!#16", Base.Pairs{Symbol, Any, Tuple{Symbol, Symbol}, NamedTuple{(:x, :verbose), Tuple{Array{Float16, 1}, Int64}}}, typeof(SolverCore.solve!), CaNNOLeS.CaNNOLeSSolver{Ti, Float16, Array{Float16, 1}, CaNNOLeS.LDLFactStruct{_A, Ti}, _A} where _A where Ti<:Integer where _A where Ti<:Integer, ADNLPModels.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}, SolverCore.GenericExecutionStats{Float16, Array{Float16, 1}, Array{Float16, 1}, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c4b274e0)[Core.MethodMatch(spec_types=Tuple{SolverCore.var"##solve!#16", Base.Pairs{Symbol, Any, Tuple{Symbol, Symbol}, NamedTuple{(:x, :verbose), Tuple{Array{Float16, 1}, Int64}}}, typeof(SolverCore.solve!), CaNNOLeS.CaNNOLeSSolver{Ti, Float16, Array{Float16, 1}, CaNNOLeS.LDLFactStruct{_A, Ti}, _A} where _A where Ti<:Integer where _A where Ti<:Integer, ADNLPModels.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}, SolverCore.GenericExecutionStats{Float16, Array{Float16, 1}, Array{Float16, 1}, Any}}, sparams=svec(), method=var"#solve!#16"(Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where T<:Tuple{Vararg{Any, N}} where names where N where V, typeof(SolverCore.solve!), SolverCore.AbstractOptimizationSolver, NLPModels.AbstractNLPModel{T, S} where S where T, SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.vector_mode_jacobian), ForwardDiff.var"#hessian##0#hessian##1"{ADNLPModels.var"#64#65"{Array{Float16, 1}, _A}, ForwardDiff.HessianConfig{T, V, N, DG, DJ}} where DJ where DG where N where V where T where _A, Array{Float16, 1}, ForwardDiff.JacobianConfig{T, Float16, _A, DJ} where DJ<:(Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A) where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A))}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb6a2b80)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.vector_mode_jacobian), ForwardDiff.var"#hessian##0#hessian##1"{ADNLPModels.var"#64#65"{Array{Float16, 1}, _A}, ForwardDiff.HessianConfig{T, V, N, DG, DJ}} where DJ where DG where N where V where T where _A, Array{Float16, 1}, ForwardDiff.JacobianConfig{T, Float16, _A, DJ} where DJ<:(Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A) where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A))}, sparams=svec(F<:(ForwardDiff.var"#hessian##0#hessian##1"{ADNLPModels.var"#64#65"{Array{Float16, 1}, _A}, ForwardDiff.HessianConfig{T, V, N, DG, DJ}} where DJ where DG where N where V where T where _A), T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A))), method=vector_mode_jacobian(F, Any, 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=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.Generator{I, Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}} where I<:(Base.Generator{Array{Int64, 1}, F} where F<:(NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T)), Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cf5203e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.Generator{I, Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}} where I<:(Base.Generator{Array{Int64, 1}, F} where F<:(NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T)), Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.to_indices), Array{Float16, 1}, Tuple{Integer}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(6, 0x7f94c3cbe1e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.to_indices), Array{Float16, 1}, Tuple{Int64}}, sparams=svec(), method=to_indices(Any, Tuple{Vararg{Int64}}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.to_indices), Array{Float16, 1}, Tuple{Integer}}, sparams=svec(), method=to_indices(Any, Tuple{Vararg{Integer}}), fully_covers=true), #, #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000fda, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{NLPModels.var"##_#43", Array{Float16, 1}, Array{Float16, 1}, Array{Float16, 1}, Int64, Int64, Int64, Int64, Array{Float16, 1}, Array{Float16, 1}, Array{Float16, 1}, Int64, Any, Int64, Any, Any, Array{Int64, 1}, Bool, Bool, String, Type{NLPModels.NLPModelMeta{Float16, Array{Float16, 1}}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c7c9c9c0)[Core.MethodMatch(spec_types=Tuple{NLPModels.var"##_#43", Array{Float16, 1}, Array{Float16, 1}, Array{Float16, 1}, Int64, Int64, Int64, Int64, Array{Float16, 1}, Array{Float16, 1}, Array{Float16, 1}, Int64, Any, Int64, Any, Any, Array{Int64, 1}, Bool, Bool, String, Type{NLPModels.NLPModelMeta{Float16, Array{Float16, 1}}}, Int64}, sparams=svec(Float16, Array{Float16, 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=0x00000000000096aa, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Type{Bool}, Base.SubArray{Tuple{Function, Function, Array{Float64, 1}, Array{Float64, 1}}, 1, Array{Tuple{Function, Function, Array{Float64, 1}, Array{Float64, 1}}, 1}, Tuple{Base.UnitRange{Int64}}, true}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c2091960)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Type{Bool}, Base.SubArray{Tuple{Function, Function, Array{Float64, 1}, Array{Float64, 1}}, 1, Array{Tuple{Function, Function, Array{Float64, 1}, Array{Float64, 1}}, 1}, Tuple{Base.UnitRange{Int64}}, true}, Int64}, sparams=svec(), method=checkbounds(Type{Bool}, AbstractArray{T, N} where N where T, Any), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000127a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eachindex), Base.IndexLinear, Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:Function), Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c08095e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), Base.IndexLinear, Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:Function), Array{Float16, 1}}, sparams=svec(), method=eachindex(Base.IndexLinear, AbstractArray{T, N} where N where T, (AbstractArray{T, N} where N where T)...), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000125b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Type{Bool}, Array{Float64, 1}, Base.UnitRange{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fe4f7ee0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Type{Bool}, Array{Float64, 1}, Base.UnitRange{Int64}}, sparams=svec(), method=checkbounds(Type{Bool}, AbstractArray{T, N} where N where T, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000127a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bf8716a0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}}, sparams=svec(), method=Typeof(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000028, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(CaNNOLeS.get_vals), CaNNOLeS.LDLFactStruct{T, Ti} where Ti<:Integer where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cc278d80)[Core.MethodMatch(spec_types=Tuple{typeof(CaNNOLeS.get_vals), CaNNOLeS.LDLFactStruct{T, Ti} where Ti<:Integer where T}, sparams=svec(), method=get_vals(CaNNOLeS.LinearSolverStruct), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096eb, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._xfadjoint), Base.BottomRF{typeof(Base.add_sum)}, Base.Generator{I, Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}} where I<:(Base.Generator{Array{Int64, 1}, F} where F<:(NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{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, 0x7f94cdf68640)[Core.MethodMatch(spec_types=Tuple{typeof(Base._xfadjoint), Base.BottomRF{typeof(Base.add_sum)}, Base.Generator{I, Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}} where I<:(Base.Generator{Array{Int64, 1}, F} where F<:(NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T))}, sparams=svec(), method=_xfadjoint(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000031f7, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Array{Int64, 1}, Real}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c3a990e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Array{Int64, 1}, Real}, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.GenericIOBuffer{Memory{UInt8}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ce62ea40)[Core.MethodMatch(spec_types=Tuple{Type{Base.GenericIOBuffer{Memory{UInt8}}}}, sparams=svec(), method=(::Type{Base.GenericIOBuffer{Memory{UInt8}}})(), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003926, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._trimmedshape), Array{T, 1} where T<:Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c03f8de0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base._trimmedshape), Array{T, 1} where T<:Integer}, sparams=svec(), method=_trimmedshape(AbstractArray{var"#s16", N} where N where var"#s16"<:Real, Any...), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002db4, max_world=0xffffffffffffffff), ambig=true), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IndexStyle}, Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F))}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94cc042060)[ Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F))}, sparams=svec(), method=(::Type{Base.IndexStyle})(AbstractArray{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000fa4, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(<)), Integer, Any}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{NamedTuple{(:x0, :ncon, :y0, :lcon, :ucon, :nnzj, :nnzh, :nln_nnzj, :name, :minimize), T} where T<:Tuple}, Tuple{Array{Float64, 1}, Int64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Any, Any, Any, String, Bool}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c16ded20)[Core.MethodMatch(spec_types=Tuple{Type{NamedTuple{(:x0, :ncon, :y0, :lcon, :ucon, :nnzj, :nnzh, :nln_nnzj, :name, :minimize), T} where T<:Tuple}, Tuple{Array{Float64, 1}, Int64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Any, Any, Any, String, Bool}}, sparams=svec((:x0, :ncon, :y0, :lcon, :ucon, :nnzj, :nnzh, :nln_nnzj, :name, :minimize)), method=(::Type{NamedTuple{names, T} where T<:Tuple})(Tuple) where {names}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000183, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.identity), Tuple{Array{Float16, 1}}, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cf6b6940)[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{Float16, 1}}, Any}, sparams=svec(typeof(Base.identity)), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Array{Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}, 1}}, UndefInitializer, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ca24c380)[Core.MethodMatch(spec_types=Tuple{Type{Array{Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}, 1}}, UndefInitializer, Tuple{Int64}}, sparams=svec(Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}), 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.:(var"==")), Any, Dates.TimeType}, limit=3), nothing, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{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, 0x7f94cf80b2a0)[Core.MethodMatch(spec_types=Tuple{NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T, Int64}, sparams=svec(), method=(::NLPModels.var"#jac_structure!##0#jac_structure!##1"{nlp, rows, i})(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096aa, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N where N where V where T, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A, Tuple{Vararg{ForwardDiff.Partials{N, ForwardDiff.Dual{T, V, N}}, N}} where N where V where T, ForwardDiff.Partials{N, V} where V where N}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f95003bf280)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A, Tuple{Vararg{ForwardDiff.Partials{N, ForwardDiff.Dual{T, V, N}}, N}} where N where V where T, ForwardDiff.Partials{N, V}} where N where V where T, sparams=svec(T, V, N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any, ForwardDiff.Partials{N, V}) where {T, V, N}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}), Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94be9a6160)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}), Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}, Int64}, sparams=svec(), method=getindex(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000669, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unsafe_convert), Type{Ptr{Float16}}, GenericMemoryRef{:not_atomic, Float16, Core.AddrSpace{Core}(0x00)}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c05c9ea0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_convert), Type{Ptr{Float16}}, GenericMemoryRef{:not_atomic, Float16, Core.AddrSpace{Core}(0x00)}}, sparams=svec(Float16), method=unsafe_convert(Type{Ptr{T}}, GenericMemoryRef{isatomic, T, addrspace} where addrspace where T where isatomic) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c84, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A, Array{Float16, 1}, ForwardDiff.Partials{_A, Float16} where _A, ForwardDiff.Partials{_A, Float16} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ca27a600)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, N}, 1}, Array{Float16, 1}, ForwardDiff.Partials{_A, Float16} where _A, ForwardDiff.Partials{N, Float16}} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), Float16, N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any, ForwardDiff.Partials{N, V}) where {T, V, N}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:Array{Int64, 1}, Array{Int64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c55d11a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Array{Int64, 1}}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:Array{Int64, 1}, Array{Int64, 1}}, sparams=svec(var"#s175"<:Array{Int64, 1}), method=convert(Type{T}, AbstractArray{T, N} where N where T) where {T<:(Array{T, N} where N where T)}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010dd, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A, Array{Float16, 1}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ccafffc0)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A, Array{Float16, 1}, Int64}, sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), Float16, _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=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_type), Type{Bool}, Type{Float16}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0dc2520)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_type), Type{Bool}, Type{Float16}}, sparams=svec(Bool, Float16), method=promote_type(Type{T}, Type{S}) where {T, S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000005f9, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c3e1e060)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Tuple{Int64}}, sparams=svec(), method=(::Type{BoundsError})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000005f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.jac_structure!), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, Array{Int64, 1}, Array{Int64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cf257ec0)[Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_structure!), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, Array{Int64, 1}, Array{Int64, 1}}, sparams=svec(Int64), method=jac_structure!(NLPModels.AbstractNLPModel{T, S} where S where T, AbstractArray{T, 1}, AbstractArray{T, 1}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096aa, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._cat_t), Base.Val{1}, Type{Tuple{Function, Function, Array{Float64, 1}, Array{Float64, 1}}}, Tuple{Main.var"#F_linear#cannoles_tests##0", Main.var"#c_linear#cannoles_tests##10", Array{Float64, 1}, Array{Float64, 1}}, Tuple{Main.var"#F_Rosen#cannoles_tests##1", Main.var"#c_linear#cannoles_tests##10", Array{Float64, 1}, Array{Float64, 1}}, Tuple{Main.var"#cannoles_tests##18#cannoles_tests##19"{Main.var"#F_under#cannoles_tests##7", Int64}, Main.var"#c_linear#cannoles_tests##10", Array{Float64, 1}, Array{Float64, 1}}, Tuple{Main.var"#F_linear#cannoles_tests##0", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}, Tuple{Main.var"#F_Rosen#cannoles_tests##1", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}, Tuple{Main.var"#cannoles_tests##22#cannoles_tests##23"{Main.var"#F_larger#cannoles_tests##2"}, Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fd5c4e80)[Core.MethodMatch(spec_types=Tuple{typeof(Base._cat_t), Base.Val{1}, Type{Tuple{Function, Function, Array{Float64, 1}, Array{Float64, 1}}}, Tuple{Main.var"#F_linear#cannoles_tests##0", Main.var"#c_linear#cannoles_tests##10", Array{Float64, 1}, Array{Float64, 1}}, Tuple{Main.var"#F_Rosen#cannoles_tests##1", Main.var"#c_linear#cannoles_tests##10", Array{Float64, 1}, Array{Float64, 1}}, Tuple{Main.var"#cannoles_tests##18#cannoles_tests##19"{Main.var"#F_under#cannoles_tests##7", Int64}, Main.var"#c_linear#cannoles_tests##10", Array{Float64, 1}, Array{Float64, 1}}, Tuple{Main.var"#F_linear#cannoles_tests##0", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}, Tuple{Main.var"#F_Rosen#cannoles_tests##1", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}, Tuple{Main.var"#cannoles_tests##22#cannoles_tests##23"{Main.var"#F_larger#cannoles_tests##2"}, Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}, sparams=svec(Tuple{Function, Function, Array{Float64, 1}, Array{Float64, 1}}), method=_cat_t(Any, Type{T}, Any...) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000013a5, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.SubArray{_A, _B, P, I, false} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ce005240)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.SubArray{_A, _B, P, I, false} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isbitstype), Type{Tuple{Main.var"#cannoles_tests##16#cannoles_tests##17"{Main.var"#F_under#cannoles_tests##7", Int64}, Array{Float64, 1}, Array{Float64, 1}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cebc2540)[Core.MethodMatch(spec_types=Tuple{typeof(Base.isbitstype), Type{Tuple{Main.var"#cannoles_tests##16#cannoles_tests##17"{Main.var"#F_under#cannoles_tests##7", Int64}, Array{Float64, 1}, Array{Float64, 1}}}}, sparams=svec(), method=isbitstype(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000503, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f950055c860)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c}, 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.kwcall), NamedTuple{(:show_time, :x0), Tuple{Bool, Array{Float16, 1}}}, Any, Int64, ADNLPModels.var"#55#56", Int64, ADNLPModels.var"#F!#369"{Main.var"#F_Rosen#cannoles_tests##1", Int64}}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.tail), Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Array{Float16, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bec656a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.tail), Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Array{Float16, 1}}}, sparams=svec(), method=tail(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000035d, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_rule), Type{Bool}, Type{Float16}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94feb04560)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_rule), Type{Bool}, Type{Float16}}, sparams=svec(Float16), method=promote_rule(Type{Bool}, Type{T}) where {T<:Number}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000a0d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.structural_length), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0c3fca0)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.structural_length), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A}, sparams=svec(), method=structural_length(AbstractArray{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{SolverCore.GenericExecutionStats{_A, _B, _C, _D}} where _D where _C where _B where _A, Bool, Symbol, Bool, Any, Bool, Any, Bool, Any, Bool, Any, Bool, Any, Bool, Any, Any, Bool, Int64, Bool, Float64, Bool, Base.Dict{Symbol, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb7a1620)[Core.MethodMatch(spec_types=Tuple{Type{SolverCore.GenericExecutionStats{_A, _B, _C, _D}} where _D where _C where _B where _A, Bool, Symbol, Bool, Any, Bool, Any, Bool, Any, Bool, Any, Bool, Any, Bool, Any, Any, Bool, Int64, Bool, Float64, Bool, Base.Dict{Symbol, Any}}, 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=0x00000000000096b2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{ForwardDiff.HessianConfig{T, V, N, DG, DJ} where DJ where DG where N where V where T}, ForwardDiff.JacobianConfig{T, Float16, _A, Array{ForwardDiff.Dual{T, Float16, _A}, 1}} where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), ForwardDiff.GradientConfig{T, V, _A, Array{ForwardDiff.Dual{T, V, _A}, 1}} where _A where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A) where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A) where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A))}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb5d0100)[Core.MethodMatch(spec_types=Tuple{Type{ForwardDiff.HessianConfig{T, V, N, DG, DJ} where DJ where DG where N where V where T}, ForwardDiff.JacobianConfig{T, Float16, N, Array{ForwardDiff.Dual{T, Float16, _A}, 1}}, ForwardDiff.GradientConfig{T, ForwardDiff.Dual{T, Float16, N}, N, Array{ForwardDiff.Dual{T, V, _A}, 1}}} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A) where _A where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), Float16, N, DG<:(Array{ForwardDiff.Dual{T, V, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A) where _A), DJ<:(Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A)), method=(::Type{ForwardDiff.HessianConfig{T, V, N, DG, DJ} where DJ where DG where N where V where T})(ForwardDiff.JacobianConfig{T, V, N, DJ}, ForwardDiff.GradientConfig{T, ForwardDiff.Dual{T, V, N}, N, DG}) where {T, V, N, DG, DJ}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.memoryref), Memory{ForwardDiff.Dual{T, V, _A}} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A) where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb3e5840)[Core.MethodMatch(spec_types=Tuple{typeof(Core.memoryref), Memory{ForwardDiff.Dual{T, V, _A}} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A) where _A}, 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(ForwardDiff.seed!), Any, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c04e18e0)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A} where N where V where T, sparams=svec(T, V, N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any) where {T, V, N}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Array{Int64, 1}, Real} where var"#s175"<:Tuple{Array{Int64, 1}, Real}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c52018e0)[Core.MethodMatch(spec_types=Tuple{Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Array{Int64, 1}, Real} where var"#s175"<:Tuple{Array{Int64, 1}, Real}, Int64}, sparams=svec(var"#s175"<:Tuple{Array{Int64, 1}, Real}), method=(::Base.var"#cvt1#convert##0"{T, x})(Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000376, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{SparseMatricesCOO.SparseMatrixCOO{Float16, _A}} where _A, Int64, Int64, Array{T, 1} where T, Array{T, 1} where T, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c52480c0)[Core.MethodMatch(spec_types=Tuple{Type{SparseMatricesCOO.SparseMatrixCOO{Float16, Ti}}, Int64, Int64, Array{Ti, 1}, Array{Ti, 1}, Array{Float16, 1}} where Ti<:Integer, sparams=svec(Float16, Ti<:Integer), method=(::Type{SparseMatricesCOO.SparseMatrixCOO{Tv, Ti}})(Integer, Integer, Array{Ti, 1}, Array{Ti, 1}, Array{Tv, 1}) where {Tv, Ti<:Integer}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ea, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:x0,), Tuple{Array{Float64, 1}}}, Any, Int64, ADNLPModels.var"#45#46", Int64, ADNLPModels.var"#c!#370"{var"#s179"} where var"#s179"<:Function}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A, Array{Float16, 1}, Int64, Tuple{Vararg{ForwardDiff.Partials{_A, Float16}, _A}} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c5284460)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, N}, 1}, Array{Float16, 1}, Int64, Tuple{Vararg{ForwardDiff.Partials{N, Float16}, N}}} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), Float16, N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any, Tuple{Vararg{ForwardDiff.Partials{N, V}, N}}) where {T, V, N}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{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!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T), Array{Int64, 1}}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cf99c1a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{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!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T), Array{Int64, 1}}, Int64, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000689, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), Base.SubArray{_A, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{T, 1} where T) where _A, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, Nothing, typeof(Base.identity), Tuple{Float16}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94bf723d60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.SubArray{_A, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{T, 1} where T) where _A, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, Nothing, typeof(Base.identity), Tuple{Float16}}}, sparams=svec(), method=materialize!(Any, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048be, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.SubString{T}} where T<:AbstractString, AbstractString, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c2a4e440)[Core.MethodMatch(spec_types=Tuple{Type{Base.SubString{T}}, T, Int64, Int64} where T<:AbstractString, sparams=svec(T<:AbstractString), method=(::Type{Base.SubString{T}})(T, Int64, Int64) where {T<:AbstractString}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000375d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.ComposedFunction{O, I} where I where O}, typeof(Base.identity), Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{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, 0x7f94cf5bc7c0)[Core.MethodMatch(spec_types=Tuple{Type{Base.ComposedFunction{O, I} where I where O}, typeof(Base.identity), Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64}} where Si where S where T}, sparams=svec(), method=(::Type{Base.ComposedFunction{O, I} where I where O})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c23, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.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{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{Bool}, Tuple{Int64}}}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cf93f400)[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{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, 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=0x00000000000047b2, 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<:(Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}), Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94be9a56a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._getindex), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}), Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}, Int64}, sparams=svec(), method=_getindex(Tuple, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000489a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cdcb8260)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}}, Tuple{Int64}}, sparams=svec(), method=(::Type{BoundsError})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000005f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), Base.SubArray{_A, _B, P, I, false} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A, Float16, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c84928e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Base.SubArray{T, 1, P, I, false} where I<:Tuple where P<:(AbstractArray{T, N} where N where T), Float16, Int64} where T, 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=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Base.SubArray{_A, _B, P, I, false} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A, Float16, Any}, sparams=svec(), method=setindex!(AbstractArray{T, N} where N where T, Any, Any...), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002e07, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IndexStyle}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Float16}}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c1dfa9c0)[Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Float16}}}}}, sparams=svec(), method=(::Type{Base.IndexStyle})(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047e9, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.CanonicalIndexError}, String, Type{Array{Float16, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c09662a0)[Core.MethodMatch(spec_types=Tuple{Type{Base.CanonicalIndexError}, String, Type{Array{Float16, 1}}}, sparams=svec(), method=(::Type{Base.CanonicalIndexError})(String, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012d6, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(CaNNOLeS.line_search), Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Base.SubArray{Float64, 1, Array{Float64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.SubArray{Float64, 1, Array{Float64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, SparseMatricesCOO.SparseMatrixCOO{Float64, Ti} where Ti<:Integer, SparseMatricesCOO.SparseMatrixCOO{Float64, Ti} where Ti<:Integer, CaNNOLeS.var"#ϕ#10", Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, CaNNOLeS.var"#F!#8"{ADNLPModels.ADNLSModel{Float64, Array{Float64, 1}, Array{Int64, 1}}}, CaNNOLeS.var"#c!#9"{ADNLPModels.ADNLSModel{Float64, Array{Float64, 1}, Array{Int64, 1}}, Array{Float64, 1}, Int64}, Float64, Float64, Float64, Bool, Symbol, CaNNOLeS.ParamCaNNOLeS{Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cf48f040)[Core.MethodMatch(spec_types=Tuple{typeof(CaNNOLeS.line_search), Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Base.SubArray{Float64, 1, Array{Float64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.SubArray{Float64, 1, Array{Float64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, SparseMatricesCOO.SparseMatrixCOO{Float64, Ti} where Ti<:Integer, SparseMatricesCOO.SparseMatrixCOO{Float64, Ti} where Ti<:Integer, CaNNOLeS.var"#ϕ#10", Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, CaNNOLeS.var"#F!#8"{ADNLPModels.ADNLSModel{Float64, Array{Float64, 1}, Array{Int64, 1}}}, CaNNOLeS.var"#c!#9"{ADNLPModels.ADNLSModel{Float64, Array{Float64, 1}, Array{Int64, 1}}, Array{Float64, 1}, Int64}, Float64, Float64, Float64, Bool, Symbol, CaNNOLeS.ParamCaNNOLeS{Float64}}, sparams=svec(Float64), method=line_search(AbstractArray{T, 1}, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096eb, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.has_offset_axes), Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c))}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f9500367f80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.has_offset_axes), Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c))}, sparams=svec(), method=has_offset_axes(Array{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001232, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.has_offset_axes), Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb6f0c40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.has_offset_axes), Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), Array{Float16, 1}}, sparams=svec(), method=has_offset_axes(Any, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001233, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), Base.SubArray{Any, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{T, 1} where T<:Union{Float32, Float64}), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, Nothing, typeof(Base.identity), Tuple{Float16}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94cec3d360)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.SubArray{Any, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{T, 1} where T<:Union{Float32, Float64}), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, Nothing, typeof(Base.identity), Tuple{Float16}}}, sparams=svec(), method=materialize!(Any, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048be, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94ca6dd4e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, sparams=svec(), method=combine_styles(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), Any}, sparams=svec(), method=combine_styles(Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004831, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{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, 0x7f95000d9920)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:var"join(keys(STATUSES), \", \")",), Tuple{String}}, typeof(Base.CoreLogging.handle_message_nothrow), Base.CoreLogging.AbstractLogger, Base.CoreLogging.LogLevel, String, Module, Symbol, Symbol, String, Int64}, sparams=svec(), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(Base.CoreLogging.handle_message_nothrow), Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004f81, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real} where var"#s175"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c3c8ff80)[Core.MethodMatch(spec_types=Tuple{Base.var"#cvt1#convert##0"{var"#s175", var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real} where var"#s175"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Int64}, sparams=svec(var"#s175"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}), method=(::Base.var"#cvt1#convert##0"{T, x})(Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000376, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.preprocess), 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{Nothing, var"#s179", typeof(Base.identity), Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}} where var"#s179"<:Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cddee4e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.preprocess), 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{Nothing, var"#s179", typeof(Base.identity), Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}} where var"#s179"<:Tuple}, sparams=svec(), method=preprocess(Any, Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048ca, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.DimensionMismatch}, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ca584620)[Core.MethodMatch(spec_types=Tuple{Type{Base.DimensionMismatch}, String}, sparams=svec(), method=(::Type{Base.DimensionMismatch})(AbstractString), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001078, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.jac_nln_coord!), NLPModels.AbstractNLPModel{T, S} where S where T, Array{T, N} 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=(2,), mem=Memory{Any}(4, 0x7f94c8cc7ee0)[ Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_nln_coord!), Main.MGH01CON{T, S} where S where T, Array{T, 1} where T, Base.SubArray{T, 1, P, I, L} where L where I where P where T}, sparams=svec(), method=jac_nln_coord!(Main.MGH01CON{T, S} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_nln_coord!), Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, Array{T, 1} where T, Base.SubArray{T, 1, P, I, L} where L where I where P where T}, sparams=svec(), method=jac_nln_coord!(Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T), fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009715, 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{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ca3a57c0)[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{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}, Tuple{Base.OneTo{Int64}}}, sparams=svec(typeof(Base.:(+))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Base.Iterators.Zip{Is} where Is<:Tuple{Base.UnitRange{Int64}, Base.Iterators.Take{I} where I}, Tuple{Int64, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cc949500)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Base.Iterators.Zip{Is} where Is<:Tuple{Base.UnitRange{Int64}, Base.Iterators.Take{I} where I}, Tuple{Int64, Any}}, sparams=svec(), method=iterate(Base.Iterators.Zip{Is} where Is<:Tuple, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000018c2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}), Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}}, UInt64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94beaef5a0)[Core.MethodMatch(spec_types=Tuple{Type{MethodError}, typeof(Base.convert), Tuple{Type, Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}), Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{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{Memory{typeof(DataType)}}, UndefInitializer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c50d5720)[Core.MethodMatch(spec_types=Tuple{Type{Memory{typeof(DataType)}}, UndefInitializer, Int64}, sparams=svec(typeof(DataType), Core.AddrSpace{Core}(0x00), :not_atomic), method=(::Type{GenericMemory{kind, T, addrspace}})(UndefInitializer, Int64) where {T, addrspace, kind}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000100, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ReverseDiff.seeded_reverse_pass!), Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Any, ReverseDiff.TrackedArray{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}}, ReverseDiff.GradientTape{F, ReverseDiff.TrackedArray{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}}, _A} where _A where F<:Function}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7f94bfb21860)[ Core.MethodMatch(spec_types=Tuple{typeof(ReverseDiff.seeded_reverse_pass!), Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, AbstractArray{T, N} where N where T, ReverseDiff.TrackedArray{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}}, ReverseDiff.GradientTape{F, ReverseDiff.TrackedArray{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}}, _A} where _A where F<:Function}, sparams=svec(), method=seeded_reverse_pass!(AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T, ReverseDiff.TrackedArray{V, D, N, VA, DA} where DA where VA where N where D where V, Any), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(ReverseDiff.seeded_reverse_pass!), Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, ReverseDiff.TrackedReal{V, D, O} where O where D<:Real where V<:Real, ReverseDiff.TrackedArray{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}}, ReverseDiff.GradientTape{F, ReverseDiff.TrackedArray{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}}, _A} where _A where F<:Function}, sparams=svec(), method=seeded_reverse_pass!(Any, ReverseDiff.TrackedReal{V, D, O} where O where D<:Real where V<:Real, Any, Any), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(ReverseDiff.seeded_reverse_pass!), Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Number, ReverseDiff.TrackedArray{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}}, ReverseDiff.GradientTape{F, ReverseDiff.TrackedArray{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}}, _A} where _A where F<:Function}, sparams=svec(), method=seeded_reverse_pass!(Any, Number, Any, Any), fully_covers=false), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._any_tuple), Base.var"#TupleOrBottom##0#TupleOrBottom##1", Bool, Type}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c4730a60)[Core.MethodMatch(spec_types=Tuple{typeof(Base._any_tuple), Base.var"#TupleOrBottom##0#TupleOrBottom##1", Bool, Type}, sparams=svec(), method=_any_tuple(Any, Any, Any, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001ad6, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{LinearAlgebra.Diagonal{Float16, Array{Float16, 1}}}, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ca485360)[Core.MethodMatch(spec_types=Tuple{Type{LinearAlgebra.Diagonal{Float16, Array{Float16, 1}}}, Array{Float16, 1}}, sparams=svec(Float16, Array{Float16, 1}), method=(::Type{LinearAlgebra.Diagonal{T, V}})(Any) where {T, V<:AbstractArray{T, 1}}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000008b01, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.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{Array{Float64, 1}, Array{Float64, 1}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ffc03620)[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{Array{Float64, 1}, Array{Float64, 1}}}}, sparams=svec(Nothing, Tuple{Base.OneTo{Int64}}, 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"#s677", Axes, F, Args} where var"#s677") where {NewStyle, Axes, F, Args}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047d1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IndexStyle}, Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(+)), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{Bool}, Tuple{Int64}}}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94cc2dac60)[ Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(+)), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{Bool}, Tuple{Int64}}}}}}, sparams=svec(), method=(::Type{Base.IndexStyle})(Type{var"#s677"} where var"#s677"<:(Base.Broadcast.Broadcasted{var"#s676", var"#s675", F, Args} where Args<:Tuple where F where var"#s675"<:Tuple{Any} where var"#s676")), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047ea, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.mightalias), Array{Float16, 1}, Array{T, 1} where T<:Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94bf07e3a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.mightalias), Array{Float16, 1}, Array{T, 1} where T<: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=0x0000000000001312, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SolverCore.solve!), CaNNOLeS.CaNNOLeSSolver{Int64, _A, _B, CaNNOLeS.MA57Struct, _C} where _C where _B where _A, ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94cca60c60)[ Core.MethodMatch(spec_types=Tuple{typeof(SolverCore.solve!), CaNNOLeS.CaNNOLeSSolver{Int64, T, V, CaNNOLeS.MA57Struct, M}, ADNLPModels.ADNLSModel{T, V, Si} where Si, SolverCore.GenericExecutionStats{T, V, V, Tsp} where Tsp} where M<:CaNNOLeS.HessianStruct{Int64} where V where T, sparams=svec(Int64, T, V, CaNNOLeS.MA57Struct, M<:CaNNOLeS.HessianStruct{Int64}), method=solve!(CaNNOLeS.CaNNOLeSSolver{Ti, T, V, F, M}, NLPModels.AbstractNLSModel{T, V}, SolverCore.GenericExecutionStats{T, V, V, Tsp} where Tsp) where {Ti, T, V, F, M<:CaNNOLeS.HessianStruct{Ti}}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(SolverCore.solve!), CaNNOLeS.CaNNOLeSSolver{Int64, _A, _B, CaNNOLeS.MA57Struct, _C} where _C where _B where _A, ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T}, sparams=svec(), method=solve!(SolverCore.AbstractOptimizationSolver, NLPModels.AbstractNLPModel{T, S} where S where T, SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096eb, 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, 0x7f94c8493520)[ 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=0x0000000000009698, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ADNLPModels.hessian), ADNLPModels.ADBackend, ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7f94c2592ee0)[ Core.MethodMatch(spec_types=Tuple{typeof(ADNLPModels.hessian), ADNLPModels.ForwardDiffADHessian, ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c, Array{Float16, 1}}, sparams=svec(), method=hessian(ADNLPModels.ForwardDiffADHessian, Any, Any), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(ADNLPModels.hessian), ADNLPModels.ReverseDiffADHessian, ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c, Array{Float16, 1}}, sparams=svec(), method=hessian(ADNLPModels.ReverseDiffADHessian, Any, Any), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(ADNLPModels.hessian), ADNLPModels.ADBackend, ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c, Array{Float16, 1}}, sparams=svec(), method=hessian(ADNLPModels.ADBackend, Any, Any), fully_covers=true), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ad, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.throw_boundserror), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c3e1d560)[Core.MethodMatch(spec_types=Tuple{typeof(Base.throw_boundserror), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Tuple{Int64}}, sparams=svec(), method=throw_boundserror(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000310, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.ComposedFunction{O, I} where I where O}, typeof(Base.identity), Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}, Array{Int64, 1}, Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cdda2bc0)[Core.MethodMatch(spec_types=Tuple{Type{Base.ComposedFunction{O, I} where I where O}, typeof(Base.identity), Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}, Array{Int64, 1}, Int64}}}, sparams=svec(), method=(::Type{Base.ComposedFunction{O, I} where I where O})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c23, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Base.Iterators.Zip{Is} where Is<:Tuple{Base.UnitRange{Int64}, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb449000)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Base.Iterators.Zip{Is} where Is<:Tuple{Base.UnitRange{Int64}, Any}}, sparams=svec(), method=iterate(Base.Iterators.Zip{Is} where Is<:Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000018c1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unaliascopy), Array{T, 1} where T<:Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ce9ae000)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unaliascopy), Array{T, 1} where T<:Integer}, sparams=svec(), method=unaliascopy(Array{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000130b, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._similar_shape), 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}, _A}} where _A), Base.HasShape{1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c33570e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._similar_shape), Base.Generator{Base.UnitRange{Int64}, F} where F<:(Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##0#__cat_offset1!##1"{Tuple{Int64}, Tuple{Bool}, Tuple{Int64}, _A}} where _A), Base.HasShape{1}}, sparams=svec(), method=_similar_shape(Any, Base.HasShape{N} where N), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010ea, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LinearOperators.reset!), SolverCore.GenericExecutionStats{T, V, V, Tsp} where Tsp where V where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb86f940)[Core.MethodMatch(spec_types=Tuple{typeof(LinearOperators.reset!), SolverCore.GenericExecutionStats{T, V, V, Tsp} where Tsp where V where T}, sparams=svec(), method=reset!(SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096b2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eachindex), Base.IndexCartesian, Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}} where var"#s179"<:Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fd8291a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), Base.IndexCartesian, Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}} where var"#s179"<: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=0x00000000000047e4, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.:(*)), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Float16}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c8ee32c0)[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{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Float16}, Nothing}, sparams=svec(typeof(Base.:(*))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#promote_eltypeof##0#promote_eltypeof##1", Type{Tuple{Function, Main.var"#c_linear#cannoles_tests##10", Array{Float64, 1}, Array{Float64, 1}}}, Tuple{Main.var"#cannoles_tests##18#cannoles_tests##19"{Main.var"#F_under#cannoles_tests##7", Int64}, Main.var"#c_linear#cannoles_tests##10", Array{Float64, 1}, Array{Float64, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ff24d400)[Core.MethodMatch(spec_types=Tuple{Base.var"#promote_eltypeof##0#promote_eltypeof##1", Type{Tuple{Function, Main.var"#c_linear#cannoles_tests##10", Array{Float64, 1}, Array{Float64, 1}}}, Tuple{Main.var"#cannoles_tests##18#cannoles_tests##19"{Main.var"#F_under#cannoles_tests##7", Int64}, Main.var"#c_linear#cannoles_tests##10", Array{Float64, 1}, Array{Float64, 1}}}, sparams=svec(Tuple{Function, Main.var"#c_linear#cannoles_tests##10", Array{Float64, 1}, Array{Float64, 1}}), method=var"#promote_eltypeof##0"(Type{T}, Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000133d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{ForwardDiff.HessianConfig{T, V, N, DG, DJ} where DJ where DG where N where V where T}, ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A, Array{Float16, 1}, ForwardDiff.Chunk{N} where N}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cbdc6780)[Core.MethodMatch(spec_types=Tuple{Type{ForwardDiff.HessianConfig{T, V, N, DG, DJ} where DJ where DG where N where V where T}, ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A, Array{Float16, 1}, ForwardDiff.Chunk{N} where N}, sparams=svec(F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A), Float16), method=(::Type{ForwardDiff.HessianConfig{T, V, N, DG, DJ} where DJ where DG where N where V where T})(F, AbstractArray{V, N} where N, ForwardDiff.Chunk{N} where N) where {F, V}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.jacobian), ForwardDiff.var"#hessian##0#hessian##1"{ADNLPModels.var"#64#65"{Array{Float16, 1}, _A}, ForwardDiff.HessianConfig{T, V, N, DG, DJ}} where DJ where DG where N where V where T where _A, Array{Float16, 1}, ForwardDiff.JacobianConfig{T, Float16, _A, DJ} where DJ<:(Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A) where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), Base.Val{false}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb694100)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.jacobian), ForwardDiff.var"#hessian##0#hessian##1"{ADNLPModels.var"#64#65"{Array{Float16, 1}, _A}, ForwardDiff.HessianConfig{T, V, N, DG, DJ}} where DJ where DG where N where V where T where _A, Array{Float16, 1}, ForwardDiff.JacobianConfig{T, Float16, _A, DJ} where DJ<:(Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A) where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), Base.Val{false}}, sparams=svec(F<:(ForwardDiff.var"#hessian##0#hessian##1"{ADNLPModels.var"#64#65"{Array{Float16, 1}, _A}, ForwardDiff.HessianConfig{T, V, N, DG, DJ}} where DJ where DG where N where V where T where _A), T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), false), 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=0x0000000000009691, 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.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}, Array{Int64, 1}, Int64}}}, Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0a51cc0)[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.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}, Array{Int64, 1}, Int64}}}, Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}}}, sparams=svec(), method=(::Type{Base.ComposedFunction{O, I} where I where O})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c23, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{CaNNOLeS.var"##solve!#5", CaNNOLeS.var"#11#12", Any, Any, Bool, Int64, Int64, Float64, Int64, Any, Any, Any, Any, Int64, Bool, Any, typeof(SolverCore.solve!), CaNNOLeS.CaNNOLeSSolver{Int64, T, V, CaNNOLeS.MA57Struct, M} where M<:CaNNOLeS.HessianStruct{Int64} where V where T, ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, SolverCore.GenericExecutionStats{T, V, V, Tsp} where Tsp where V where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0c9b080)[Core.MethodMatch(spec_types=Tuple{CaNNOLeS.var"##solve!#5", CaNNOLeS.var"#11#12", Any, Any, Bool, Int64, Int64, Float64, Int64, Any, Any, Real, Real, Int64, Bool, Any, typeof(SolverCore.solve!), CaNNOLeS.CaNNOLeSSolver{Int64, T, V, CaNNOLeS.MA57Struct, M}, ADNLPModels.ADNLSModel{T, V, Si} where Si, SolverCore.GenericExecutionStats{T, V, V, Tsp} where Tsp} where M<:CaNNOLeS.HessianStruct{Int64} where V where T, sparams=svec(Ti, T, V, F, M<:CaNNOLeS.HessianStruct{Ti}), method=var"#solve!#5"(Any, V, V, Bool, Int64, Real, Real, Int64, T, T, Real, Real, Integer, Bool, T, typeof(SolverCore.solve!), CaNNOLeS.CaNNOLeSSolver{Ti, T, V, F, M}, NLPModels.AbstractNLSModel{T, V}, SolverCore.GenericExecutionStats{T, V, V, Tsp} where Tsp) where {Ti, T, V, F, M<:CaNNOLeS.HessianStruct{Ti}}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096eb, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(>)), Tuple{Array{Float16, 1}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), Tuple{Array{Float16, 1}, Float16}}}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), Tuple{Array{Float16, 1}, Array{Float16, 1}}}}}, Type{Bool}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fde37480)[Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(>)), Tuple{Array{Float16, 1}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), Tuple{Array{Float16, 1}, Float16}}}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), Tuple{Array{Float16, 1}, Array{Float16, 1}}}}}, Type{Bool}}, sparams=svec(Bool), method=similar(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Type{T}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047d3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A, Array{Float16, 1}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0315400)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A, Array{Float16, 1}, Int64}, sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:Function), Float16, _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=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(<)), Any, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c3cc7ba0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(<)), Any, Any}, sparams=svec(typeof(Base.:(<))), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004959, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ADNLPModels.get_F), ADNLPModels.ADNLSModel{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, 0x7f94c8492320)[ Core.MethodMatch(spec_types=Tuple{typeof(ADNLPModels.get_F), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, ADNLPModels.InPlaceADbackend}, sparams=svec(), method=get_F(ADNLPModels.AbstractADNLSModel{T, S} where S where T, ADNLPModels.InPlaceADbackend), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(ADNLPModels.get_F), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, ADNLPModels.ADBackend}, sparams=svec(), method=get_F(ADNLPModels.AbstractADNLSModel{T, S} where S where T, ADNLPModels.ADBackend), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ad, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.restart_copyto_nonleaf!), Base.BitArray{1}, Base.BitArray{1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Any, Int64, Base.OneTo{Int64}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c27aeae0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.restart_copyto_nonleaf!), Base.BitArray{1}, Base.BitArray{1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Any, Int64, Base.OneTo{Int64}, Int64, Int64}, sparams=svec(), method=restart_copyto_nonleaf!(Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048ef, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Type{Bool}, Array{Float16, 1}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94cec1da60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Type{Bool}, Array{Float16, 1}, Int64}, sparams=svec(), method=checkbounds(Type{Bool}, AbstractArray{T, N} where N where T, Any), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000127a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._setindex!), Array{ForwardDiff.Dual{Nothing, Float16, N}, 1} where N, ForwardDiff.Dual{Nothing, Float16, _A} where _A, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c236efa0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._setindex!), Array{ForwardDiff.Dual{Nothing, Float16, N}, 1}, ForwardDiff.Dual{Nothing, Float16, N}, Int64} where N, sparams=svec(T<:(ForwardDiff.Dual{Nothing, Float16, N} where N)), method=_setindex!(Array{T, N} where N, T, Int64) where {T}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001118, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds_indices), Type{Bool}, Tuple, Tuple{Base.IteratorsMD.CartesianIndex{2}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c2415760)[Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds_indices), Type{Bool}, Tuple, Tuple{Base.IteratorsMD.CartesianIndex{2}}}, sparams=svec(), method=checkbounds_indices(Type{Bool}, Tuple, Tuple{Base.IteratorsMD.CartesianIndex{N} where N, Vararg}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004672, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.jac_nln_coord!), ADNLPModels.ADNLSModel{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, 0x7f94be679cc0)[Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_nln_coord!), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T}, sparams=svec(), method=jac_nln_coord!(Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ad, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.string), String, Type{StaticArraysCore.SArray{Tuple{2}, _A, N, L} where L where N} where _A, String, Int64, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c4d74700)[Core.MethodMatch(spec_types=Tuple{typeof(Base.string), String, Type{StaticArraysCore.SArray{Tuple{2}, _A, N, L} where L where N} where _A, String, Int64, String}, sparams=svec(), method=string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003db1, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(+)), Tuple{Array{Float16, 1}, Array{Float16, 1}}}, Type{Float16}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ccefce80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(+)), Tuple{Array{Float16, 1}, Array{Float16, 1}}}, Type{Float16}, Tuple{Base.OneTo{Int64}}}, sparams=svec(1, Float16), method=similar(Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{N}, Axes, F, Args} where Args<:Tuple where F where Axes, Type{ElType}, Any) where {N, ElType}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047d4, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_result), Type, Type{Tuple{Main.var"#cannoles_tests##18#cannoles_tests##19"{Main.var"#F_under#cannoles_tests##7", Int64}, Main.var"#c_linear#cannoles_tests##10", Array{Float64, 1}, Array{Float64, 1}}}, Any, Type{Tuple{Main.var"#cannoles_tests##18#cannoles_tests##19"{Main.var"#F_under#cannoles_tests##7", Int64}, Main.var"#c_linear#cannoles_tests##10", Array{Float64, 1}, Array{Float64, 1}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fe5093e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_result), Type, Type{Tuple{Main.var"#cannoles_tests##18#cannoles_tests##19"{Main.var"#F_under#cannoles_tests##7", Int64}, Main.var"#c_linear#cannoles_tests##10", Array{Float64, 1}, Array{Float64, 1}}}, Type{T}, Type{Tuple{Main.var"#cannoles_tests##18#cannoles_tests##19"{Main.var"#F_under#cannoles_tests##7", Int64}, Main.var"#c_linear#cannoles_tests##10", Array{Float64, 1}, Array{Float64, 1}}}} where T, sparams=svec(T, Tuple{Main.var"#cannoles_tests##18#cannoles_tests##19"{Main.var"#F_under#cannoles_tests##7", Int64}, Main.var"#c_linear#cannoles_tests##10", Array{Float64, 1}, Array{Float64, 1}}), method=promote_result(Type, Type, Type{T}, Type{S}) where {T, S}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000602, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.:(>)), Tuple{Array{Int64, 1}, Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fcc87300)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.:(>)), Tuple{Array{Int64, 1}, Real}}, sparams=svec(typeof(Base.:(>))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.view), Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bf6f6700)[Core.MethodMatch(spec_types=Tuple{typeof(Base.view), Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Int64}, sparams=svec(1), method=view(AbstractArray{T, N} where N where T, Vararg{Any, M}) where {M}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002dd6, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.typejoin), Type{Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}}, Type{Tuple{Main.var"#cannoles_tests##16#cannoles_tests##17"{Main.var"#F_under#cannoles_tests##7", Int64}, Array{Float64, 1}, Array{Float64, 1}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ca7cb520)[Core.MethodMatch(spec_types=Tuple{typeof(Base.typejoin), Type{Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}}, Type{Tuple{Main.var"#cannoles_tests##16#cannoles_tests##17"{Main.var"#F_under#cannoles_tests##7", Int64}, Array{Float64, 1}, Array{Float64, 1}}}}, sparams=svec(), method=typejoin(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000005e0, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.vec), Any}, limit=3), nothing, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:(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.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64}}} where Si where S where T), 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.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64}}} where Si where S where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94cf69daa0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, 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.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64}}} where Si where S where T}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, 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.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64}}} where Si where S where T} where T<:(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.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64}}} where Si where S where T), sparams=svec(T), method=convert(Type{T}, T) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000034c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{var"#s175"} where var"#s175"<:(Memory{T} where T<:(ForwardDiff.Dual{T, V, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A) where _A)), UndefInitializer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94cb2a0d20)[ Core.MethodMatch(spec_types=Tuple{Type{Union{}}, UndefInitializer, Int64}, sparams=svec(), method=(::Type{Union{}})(Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{Memory{T}}, UndefInitializer, Int64} where T<:(ForwardDiff.Dual{T, V, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A) where _A), sparams=svec(T<:(ForwardDiff.Dual{T, V, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A) where _A), Core.AddrSpace{Core}(0x00), :not_atomic), method=(::Type{GenericMemory{kind, T, addrspace}})(UndefInitializer, Int64) where {T, addrspace, kind}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000100, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(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{Array{Float64, 1}, Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ff1e5b80)[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{Array{Float64, 1}, Int64}}}, sparams=svec(Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), Tuple{Array{Float64, 1}, Int64}), method=convert(Type{Base.Broadcast.Broadcasted{NewStyle, Axes, F, Args} where Args<:Tuple where F where Axes}, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where var"#s677") where {NewStyle, Axes, F, Args}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047d1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Nothing, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Float16}}}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c344e980)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Nothing, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Float16}}}, Tuple{Base.OneTo{Int64}}}, sparams=svec(typeof(Base.:(&))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.aligned_sizeof), Type{Float16}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c83b2d60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.aligned_sizeof), Type{Float16}}, sparams=svec(), method=aligned_sizeof(Type), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000004d7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.Colon, Int64, Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94bfa6bf20)[ Core.MethodMatch(spec_types=Tuple{Base.Colon, Int64, Int64}, sparams=svec(Int64), method=Colon(T, T) where {T<:Real}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{Base.Colon, Int64, Integer}, sparams=svec(), method=Colon(Real, Real), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000082e, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{NLPModels.NLPModelMeta{_A, _B}} where _B where _A, Int64, Any, Any, Any, Any, Any, Any, Any, Any, Any, Int64, Int64, Int64, Real, Any, Any, Any, Any, Any, Any, Any, Any, Any, Int64, Any, Int64, Any, Any, Int64, Any, Array{Int64, 1}, Any, Bool, Bool, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c4a4e300)[Core.MethodMatch(spec_types=Tuple{Type{NLPModels.NLPModelMeta{_A, _B}} where _B where _A, Int64, Any, Any, Any, Any, Any, Any, Any, Any, Any, Int64, Int64, Int64, Real, Any, Any, Any, Any, Any, Any, Any, Any, Any, Int64, Any, Int64, Any, Any, Int64, Any, Array{Int64, 1}, Any, Bool, Bool, String}, sparams=svec(), method=(::Type{NLPModels.NLPModelMeta{T, S}})(Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096aa, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{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!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T), Array{Int64, 1}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cf9cb8c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{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!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T), Array{Int64, 1}}, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000688, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.reshape_jacobian), Any, AbstractArray{T, N} where N where T, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94ff88ad60)[ Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.reshape_jacobian), DiffResults.DiffResult{O, V, D} where D<:Tuple where V where O, AbstractArray{T, N} where N where T, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A}, sparams=svec(), method=reshape_jacobian(DiffResults.DiffResult{O, V, D} where D<:Tuple where V where O, Any, Any), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.reshape_jacobian), Any, AbstractArray{T, N} where N where T, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A}, sparams=svec(), method=reshape_jacobian(Any, Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}} where var"#s179"<:Tuple, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94cb4d2060)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}} where var"#s179"<: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"#s179", typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}} where var"#s179"<: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=0x000000000000925f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A, Array{Float16, 1}, ForwardDiff.Partials{_A, Float16} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c069e8e0)[ Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, N}, 1}, Array{Float16, 1}, ForwardDiff.Partials{N, Float16}} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:Function), sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:Function), Float16, 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{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A, Array{Float16, 1}, ForwardDiff.Partials{_A, Float16} where _A}, sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:Function), Float16, _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=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(+)), Any, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c3a8fe00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.:(+)), Any, Int64, Int64}, sparams=svec(), method=+(Any, Any, Any, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000bf1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.string), String, Type{StaticArraysCore.SArray{Tuple{1}, _A, N, L} where L where N} where _A, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fe00a4a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.string), String, Type{StaticArraysCore.SArray{Tuple{1}, _A, N, L} where L where N} where _A, String}, sparams=svec(), method=string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003db1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._trimmedpind), Array{T, 1} where T<:Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c03f98e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base._trimmedpind), Array{Union{}, 1}}, sparams=svec(), method=_trimmedpind(AbstractArray{var"#s16", N} where N where var"#s16"<:Base.AbstractCartesianIndex{0}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base._trimmedpind), Array{T, 1} where T<:Integer}, sparams=svec(), method=_trimmedpind(Any, Any...), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002dbc, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.length), Type{StaticArraysCore.SArray{Tuple{1}, _A, N, L} where L where N} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fccf64a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.length), Type{StaticArraysCore.SArray{Tuple{1}, _A, N, L} where L where N} where _A}, sparams=svec(SA<:(StaticArraysCore.SArray{Tuple{1}, _A, N, L} where L where N where _A)), method=length(Type{SA}) where {SA<:(Union{LinearAlgebra.Adjoint{T, var"#s5"} where var"#s5"<:Union{StaticArraysCore.StaticArray{Tuple{var"#s2"}, T, 1} where var"#s2", StaticArraysCore.StaticArray{Tuple{var"#s3", var"#s4"}, T, 2} where var"#s4" where var"#s3"}, LinearAlgebra.Diagonal{T, var"#s12"} where var"#s12"<:(StaticArraysCore.StaticArray{Tuple{var"#s13"}, T, 1} where var"#s13"), LinearAlgebra.Hermitian{T, var"#s9"} where var"#s9"<:(StaticArraysCore.StaticArray{Tuple{var"#s10", var"#s11"}, T, 2} where var"#s11" where var"#s10"), LinearAlgebra.LowerTriangular{T, var"#s17"} where var"#s17"<:(StaticArraysCore.StaticArray{Tuple{var"#s18", var"#s19"}, T, 2} where var"#s19" where var"#s18"), LinearAlgebra.Symmetric{T, var"#s6"} where var"#s6"<:(StaticArraysCore.StaticArray{Tuple{var"#s7", var"#s8"}, T, 2} where var"#s8" where var"#s7"), LinearAlgebra.Transpose{T, var"#s1"} where var"#s1"<:Union{StaticArraysCore.StaticArray{Tuple{var"#s2"}, T, 1} where var"#s2", StaticArraysCore.StaticArray{Tuple{var"#s3", var"#s4"}, T, 2} where var"#s4" where var"#s3"}, LinearAlgebra.UnitLowerTriangular{T, var"#s23"} where var"#s23"<:(StaticArraysCore.StaticArray{Tuple{var"#s24", var"#s25"}, T, 2} where var"#s25" where var"#s24"), LinearAlgebra.UnitUpperTriangular{T, var"#s20"} where var"#s20"<:(StaticArraysCore.StaticArray{Tuple{var"#s21", var"#s22"}, T, 2} where var"#s22" where var"#s21"), LinearAlgebra.UpperTriangular{T, var"#s14"} where var"#s14"<:(StaticArraysCore.StaticArray{Tuple{var"#s15", var"#s16"}, T, 2} where var"#s16" where var"#s15"), StaticArraysCore.StaticArray{Tuple{var"#s25"}, T, 1} where var"#s25", StaticArraysCore.StaticArray{Tuple{var"#s4", var"#s3"}, T, 2} where var"#s3" where var"#s4", StaticArraysCore.StaticArray{var"#s25", T, N} where N where var"#s25"<:Tuple} where T)}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009697, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Any, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7f94cb6cf6a0)[ Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A, ForwardDiff.Partials{N, V}} where N where V where T, sparams=svec(T, V, 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!), AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A, Tuple{Vararg{ForwardDiff.Partials{N, V}, N}}} where N where V where T, sparams=svec(T, V, 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!), AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A, Any} where N where V where T, sparams=svec(T, V, N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any) where {T, V, N}, fully_covers=false), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.axes), Array{ForwardDiff.Dual{Tagψ, T, 1}, 1} where T where Tagψ}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cdda03a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.axes), Array{ForwardDiff.Dual{Tagψ, T, 1}, 1} where T where Tagψ}, sparams=svec(), method=axes(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000122a, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), Base.Broadcast.DefaultArrayStyle{1}, Base.SubArray{E, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{T, 1} where T<:Union{Float32, Float64}) where E<:Union{Float32, Float64}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, Nothing, typeof(Base.identity), Tuple{Float16}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cd5180e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.Broadcast.DefaultArrayStyle{1}, Base.SubArray{E, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{T, 1} where T<:Union{Float32, Float64}) where E<:Union{Float32, Float64}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, Nothing, typeof(Base.identity), Tuple{Float16}}}, sparams=svec(), method=materialize!(Base.Broadcast.BroadcastStyle, Any, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048bf, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.pairs), NamedTuple{names, T} where T<:Tuple where names}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c524be00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.pairs), NamedTuple{names, T} where T<:Tuple where names}, sparams=svec(), method=pairs(NamedTuple{names, T} where T<:Tuple where names), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001888, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)), Type{ForwardDiff.Dual{T, V, _A}} where _A where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A) where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c))}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ff05b0c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)), Type{ForwardDiff.Dual{T, V, _A}} where _A where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A) where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c))}, sparams=svec(T<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A)), method=similar(Array{T, 1}, Type) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010b5, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), ForwardDiff.var"#partials_wrap#extract_jacobian_chunk!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), Any, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c118a8a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), ForwardDiff.var"#partials_wrap#extract_jacobian_chunk!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), Any, Any}, sparams=svec(F<:(ForwardDiff.var"#partials_wrap#extract_jacobian_chunk!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)))), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004959, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.memoryref), Memory{T} where T<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fe770380)[Core.MethodMatch(spec_types=Tuple{typeof(Core.memoryref), Memory{T} where T<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A)}, 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.similar), Type{Array{Float64, 1}}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cd4fdb00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Type{Array{Float64, 1}}, Tuple{Base.OneTo{Int64}}}, sparams=svec(Array{Float64, 1}), method=similar(Type{T}, Tuple{Union{Integer, Base.OneTo{T} where T<:Integer}, Vararg{Union{Integer, Base.OneTo{T} where T<:Integer}}}) where {T<:(AbstractArray{T, N} where N where T)}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000129c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), Array{_A, 1} where _A, Array{Float16, 1}}, limit=1), nothing, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Array{Float16, 1}, Type{Float16}, Tuple{Integer, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94bf203060)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Array{Float16, 1}, Type{Float16}, Tuple{Int64, Int64}}, sparams=svec(2), method=similar(Array{T, N} where N where T, Type, Tuple{Vararg{Int64, N}}) where {N}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Array{Float16, 1}, Type{Float16}, Tuple{Integer, Int64}}, sparams=svec(Float16), 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=0x0000000000001291, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._xfadjoint_unwrap), Base.Generator{I, Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}} where I<:(Base.Generator{Array{Int64, 1}, F} where F<:(NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{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, 0x7f94cdf6a560)[Core.MethodMatch(spec_types=Tuple{typeof(Base._xfadjoint_unwrap), Base.Generator{I, Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}} where I<:(Base.Generator{Array{Int64, 1}, F} where F<:(NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T))}, sparams=svec(), method=_xfadjoint_unwrap(Base.Generator{I, F} where F where I), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000031fa, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Array{Int64, 1}}, Array{Int64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb9ff100)[Core.MethodMatch(spec_types=Tuple{Type{Array{Int64, 1}}, Array{Int64, 1}}, sparams=svec(Int64, 1, Int64), method=(::Type{Array{T, N}})(AbstractArray{S, N}) where {T, N, S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010df, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), Array{T, 1} where T, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94ca82e560)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Array{T, 1} where T, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"}, sparams=svec(), method=materialize!(Any, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Array{T, 1} where T, Any}, sparams=svec(), method=materialize!(Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048be, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto_unaliased!), Base.IndexLinear, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.IndexLinear, Array{T, 1} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c84fd220)[Core.MethodMatch(spec_types=Tuple{typeof(Base.copyto_unaliased!), Base.IndexLinear, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, 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=0x00000000000012ae, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ADNLPModels.sparse_hess_coord!), ADNLPModels.SparseReverseADHessian{Tagf, Tagψ, R, T, C, H, S, F, P} where P where F where S where H where C where T where R where Tagψ where Tagf, Array{Float16, 1}, Float16, Array{Float16, 1}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c2ae3fc0)[Core.MethodMatch(spec_types=Tuple{typeof(ADNLPModels.sparse_hess_coord!), ADNLPModels.SparseReverseADHessian{Tagf, Tagψ, R, T, C, H, S, F, P} where P where F where S where H where C where T where R where Tagψ where Tagf, Array{Float16, 1}, Float16, Array{Float16, 1}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(Tagf, Tagψ), method=sparse_hess_coord!(ADNLPModels.SparseReverseADHessian{Tagf, Tagψ, R, T, C, H, S, F, P} where P where F where S where H where C where T where R, AbstractArray{T, 1} where T, Any, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T) where {Tagf, Tagψ}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ad, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ADNLPModels.get_c), ADNLPModels.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}, ADNLPModels.ADBackend}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c8cef020)[ Core.MethodMatch(spec_types=Tuple{typeof(ADNLPModels.get_c), ADNLPModels.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}, 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.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}, 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=0x00000000000096ad, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.chunksize), ForwardDiff.JacobianConfig{T, Float16, _A, DJ} where DJ<:(Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A) where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:Function)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c07e5c60)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.chunksize), ForwardDiff.JacobianConfig{T, Float16, _A, DJ} where DJ<:(Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A) where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:Function)}, sparams=svec(_A), method=chunksize(ForwardDiff.AbstractConfig{N}) where {N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), Array{T, 1} where T<:(ForwardDiff.Dual{T, V, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A) where _A), Array{ForwardDiff.Dual{T, V, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A) where _A}, limit=1), nothing, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{ReverseDiff.GradientConfig{I} where I}, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, Array{ReverseDiff.AbstractInstruction, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0c75440)[Core.MethodMatch(spec_types=Tuple{Type{ReverseDiff.GradientConfig{I} where I}, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, Array{ReverseDiff.AbstractInstruction, 1}}, sparams=svec(ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}), method=(::Type{ReverseDiff.GradientConfig{I} where I})(AbstractArray{T, N} where N, Array{ReverseDiff.AbstractInstruction, 1}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ReverseDiff.seeded_reverse_pass!), Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, ReverseDiff.GradientTape{F, ReverseDiff.TrackedArray{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}}, _A} where _A where F<:Function}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bfb2b7a0)[Core.MethodMatch(spec_types=Tuple{typeof(ReverseDiff.seeded_reverse_pass!), Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, ReverseDiff.GradientTape{F, ReverseDiff.TrackedArray{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}}, _A} where _A where F<:Function}, sparams=svec(), method=seeded_reverse_pass!(Any, ReverseDiff.AbstractTape), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.jac_nln_structure!), NLPModels.AbstractNLPModel{T, S} where S where T, Array{Int64, 1}, Array{Int64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c10c39e0)[ Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_nln_structure!), Main.MGH01CON{T, S} where S where T, Array{Int64, 1}, Array{Int64, 1}}, sparams=svec(), method=jac_nln_structure!(Main.MGH01CON{T, S} where S where T, AbstractArray{var"#s4", 1} where var"#s4"<:Integer, AbstractArray{var"#s3", 1} where var"#s3"<:Integer), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_nln_structure!), Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, Array{Int64, 1}, Array{Int64, 1}}, sparams=svec(), method=jac_nln_structure!(Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{var"#s103", 1} where var"#s103"<:Integer, AbstractArray{var"#s102", 1} where var"#s102"<:Integer), fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009714, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), ADNLPModels.ADModelBackend{GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS} where HBLS<:(NLPModels.AbstractNLPModel{T, S} where S where T) where JBLS where JtvBLS where JvBLS where HvBLS where GHJ where HB where JB where JtvB where JvB where HvB where GB, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c18f7020)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), ADNLPModels.ADModelBackend{GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS} where HBLS<:(NLPModels.AbstractNLPModel{T, S} where S where T) where JBLS where JtvBLS where JvBLS where HvBLS where GHJ where HB where JB where JtvB where JvB where HvB where GB, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.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.ADNLSModel{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, 0x7f94cf540b00)[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.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T}, sparams=svec(1, UnionAll), method=(::Type{Base.Fix{N, F, T} where T where F})(F, Any) where {N, F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c46, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), AbstractArray{ForwardDiff.Dual{T, ForwardDiff.Dual{T, V, N}, N}, N} where N where N where T where V where T, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A, Int64, Tuple{Vararg{ForwardDiff.Partials{N, ForwardDiff.Dual{T, V, N}}, N}} where N where T where V, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cc390e60)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), AbstractArray{ForwardDiff.Dual{T, ForwardDiff.Dual{T, V, N}, N}, N} where N, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A, Int64, Tuple{Vararg{ForwardDiff.Partials{N, ForwardDiff.Dual{T, V, N}}, N}}, Int64} where N where V where T where T, sparams=svec(T, V<:(ForwardDiff.Dual{T, V, N} where T where V where N), N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any, Tuple{Vararg{ForwardDiff.Partials{N, V}, N}}, Any) where {T, V, N}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A, Array{Float16, 1}, Any, ForwardDiff.Partials{_A, Float16} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fd192080)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, N}, 1}, Array{Float16, 1}, Any, ForwardDiff.Partials{N, Float16}} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), Float16, N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any, ForwardDiff.Partials{N, V}) where {T, V, N}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Array{Float16, 1}, Type{ForwardDiff.Dual{T, Float16, _A}} where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:Function)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c09fac80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Array{Float16, 1}, Type{ForwardDiff.Dual{T, Float16, _A}} where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:Function)}, sparams=svec(Float16), method=similar(Array{T, 1}, Type) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010b5, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.adjoint), SparseMatricesCOO.SparseMatrixCOO{T, Int64} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94cb7479a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.adjoint), SparseMatricesCOO.SparseMatrixCOO{T, Int64} where T}, sparams=svec(), method=adjoint(Union{AbstractArray{T, 1}, AbstractArray{T, 2}} where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000007ad8, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.sum), Any}, limit=3), nothing, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, Array{Float16, 1}, Array{Float16, 1}, Array{ReverseDiff.AbstractInstruction, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c7be26e0)[Core.MethodMatch(spec_types=Tuple{Type{ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, Array{Float16, 1}, Array{Float16, 1}, Array{ReverseDiff.AbstractInstruction, 1}}, sparams=svec(Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}), method=(::Type{ReverseDiff.TrackedArray{V, D, N, VA, DA}})(AbstractArray{V, N}, AbstractArray{D, N}, Array{ReverseDiff.AbstractInstruction, 1}) where {V, D, N, VA, DA}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseArrays.sparse_check_length), String, Array{Ti, 1} where Ti<:Integer, Any, Type{String}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c96a0880)[Core.MethodMatch(spec_types=Tuple{typeof(SparseArrays.sparse_check_length), String, Array{Ti, 1} where Ti<:Integer, Any, Type{String}}, sparams=svec(), method=sparse_check_length(Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009678, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unwrap_composed), Base.ComposedFunction{Base.ComposedFunction{typeof(Base.identity), Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64}}}, Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}}} where Si where S where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ce1044c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unwrap_composed), Base.ComposedFunction{Base.ComposedFunction{typeof(Base.identity), Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64}}}, Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}}} where Si where S where T}, sparams=svec(), method=unwrap_composed(Base.ComposedFunction{O, I} where I where O), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c29, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.structdiff), NamedTuple{(:x0,), Tuple{Array{Float64, 1}}}, Type{NamedTuple{(:backend, :matrix_free, :show_time, :gradient_backend, :hprod_backend, :hessian_backend, :hprod_residual_backend, :jprod_residual_backend, :jtprod_residual_backend, :jacobian_residual_backend, :hessian_residual_backend), T} where T<:Tuple}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fd4f9cc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.structdiff), NamedTuple{(:x0,), Tuple{Array{Float64, 1}}}, Type{NamedTuple{(:backend, :matrix_free, :show_time, :gradient_backend, :hprod_backend, :hessian_backend, :hprod_residual_backend, :jprod_residual_backend, :jtprod_residual_backend, :jacobian_residual_backend, :hessian_residual_backend), T} where T<:Tuple}}, sparams=svec((:x0,), (:backend, :matrix_free, :show_time, :gradient_backend, :hprod_backend, :hessian_backend, :hprod_residual_backend, :jprod_residual_backend, :jtprod_residual_backend, :jacobian_residual_backend, :hessian_residual_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=0x0000000000001aba, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(<)), Int64, Any}, 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}}, Nothing, typeof(Base.:(\)), Tuple{Bool, Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0984b80)[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{Bool, Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}, Tuple{Base.OneTo{Int64}}}, sparams=svec(typeof(Base.:(\))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Int64}, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c7c41f20)[Core.MethodMatch(spec_types=Tuple{Type{Int64}, Bool}, sparams=svec(), method=(::Type{Int64})(Union{Bool, Int128, Int16, Int32, Int64, Int8, UInt128, UInt16, UInt32, UInt64, UInt8}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000217, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(CaNNOLeS.line_search), Array{Float16, 1}, Array{Float16, 1}, Array{Float16, 1}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Array{Float16, 1}, Array{Float16, 1}, Array{Float16, 1}, SparseMatricesCOO.SparseMatrixCOO{Float16, Ti} where Ti<:Integer, SparseMatricesCOO.SparseMatrixCOO{Float16, Ti} where Ti<:Integer, CaNNOLeS.var"#ϕ#10", Array{Float16, 1}, Array{Float16, 1}, Array{Float16, 1}, Array{Float16, 1}, Array{Float16, 1}, CaNNOLeS.var"#F!#8"{ADNLPModels.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}}, CaNNOLeS.var"#c!#9"{ADNLPModels.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}, Array{Float16, 1}, Int64}, Float16, Float16, Float16, Bool, Symbol, CaNNOLeS.ParamCaNNOLeS{Float16}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cd551980)[Core.MethodMatch(spec_types=Tuple{typeof(CaNNOLeS.line_search), Array{Float16, 1}, Array{Float16, 1}, Array{Float16, 1}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Array{Float16, 1}, Array{Float16, 1}, Array{Float16, 1}, SparseMatricesCOO.SparseMatrixCOO{Float16, Ti} where Ti<:Integer, SparseMatricesCOO.SparseMatrixCOO{Float16, Ti} where Ti<:Integer, CaNNOLeS.var"#ϕ#10", Array{Float16, 1}, Array{Float16, 1}, Array{Float16, 1}, Array{Float16, 1}, Array{Float16, 1}, CaNNOLeS.var"#F!#8"{ADNLPModels.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}}, CaNNOLeS.var"#c!#9"{ADNLPModels.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}, Array{Float16, 1}, Int64}, Float16, Float16, Float16, Bool, Symbol, CaNNOLeS.ParamCaNNOLeS{Float16}}, sparams=svec(Float16), method=line_search(AbstractArray{T, 1}, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096eb, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.SubString{T} where T<:AbstractString}, AbstractString, Base.UnitRange{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c2a7d7e0)[Core.MethodMatch(spec_types=Tuple{Type{Base.SubString{T} where T<:AbstractString}, AbstractString, Base.UnitRange{Int64}}, sparams=svec(), method=(::Type{Base.SubString{T} where T<:AbstractString})(AbstractString, Base.AbstractUnitRange{var"#s215"} where var"#s215"<:Integer), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003763, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.elsize), Type{Memory{Float16}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cdf04180)[Core.MethodMatch(spec_types=Tuple{typeof(Base.elsize), Type{Memory{Float16}}}, sparams=svec(Float16, Memory{Float16}), method=elsize(Type{A}) where {T, A<:(GenericMemory{var"#s179", T, addrspace} where addrspace where var"#s179")}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000103d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.throw_boundserror), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c269a3c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.throw_boundserror), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Tuple{Int64}}, sparams=svec(), method=throw_boundserror(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000310, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Array{Int64, 1}}, Any}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{ForwardDiff.Tag{F, V} where V where F}, Any, Type{Float16}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94ffda77e0)[ Core.MethodMatch(spec_types=Tuple{Type{ForwardDiff.Tag{F, V} where V where F}, Nothing, Type{Float16}}, sparams=svec(Float16), method=(::Type{ForwardDiff.Tag{F, V} where V where F})(Nothing, Type{V}) where {V}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{ForwardDiff.Tag{F, V} where V where F}, Any, Type{Float16}}, sparams=svec(F, Float16), method=(::Type{ForwardDiff.Tag{F, V} where V where F})(F, Type{V}) where {F, V}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.typejoin), Type, Type{Tuple{Main.var"#cannoles_tests##22#cannoles_tests##23"{Main.var"#F_larger#cannoles_tests##2"}, Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fdabbc00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.typejoin), Type, Type{Tuple{Main.var"#cannoles_tests##22#cannoles_tests##23"{Main.var"#F_larger#cannoles_tests##2"}, Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}}, sparams=svec(), method=typejoin(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000005e0, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ColorTypes.comp1), ColorTypes.Colorant{T, N} where N where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7f94ce346c60)[ Core.MethodMatch(spec_types=Tuple{typeof(ColorTypes.comp1), Union{ColorTypes.AbstractRGB{T} where T, ColorTypes.TransparentColor{C, T, 4} where T where C<:(ColorTypes.AbstractRGB{T} where T)}}, sparams=svec(), method=comp1(Union{ColorTypes.AbstractRGB{T} where T, ColorTypes.TransparentColor{C, T, 4} where T where C<:(ColorTypes.AbstractRGB{T} where T)}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(ColorTypes.comp1), Union{ColorTypes.AbstractGray{T} where T, ColorTypes.TransparentColor{C, T, 2} where T where C<:(ColorTypes.AbstractGray{T} where T)}}, sparams=svec(), method=comp1(Union{ColorTypes.AbstractGray{T} where T, ColorTypes.TransparentColor{C, T, 2} where T where C<:(ColorTypes.AbstractGray{T} where T)}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(ColorTypes.comp1), ColorTypes.Colorant{T, N} where N where T}, sparams=svec(), method=comp1(ColorTypes.Colorant{T, N} where N where T), fully_covers=true), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096d6, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.vector_mode_dual_eval!), Function, ForwardDiff.GradientConfig{T, ForwardDiff.Dual{T, V, N}, N, DG} where DG where N where V where T, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c055dd80)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.vector_mode_dual_eval!), Function, ForwardDiff.GradientConfig{T, ForwardDiff.Dual{T, V, N}, N, DG} where DG where N where V where T, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A}, sparams=svec(F<:Function), method=vector_mode_dual_eval!(F, Union{ForwardDiff.GradientConfig{T, V, N, D} where D where N where V where T, ForwardDiff.JacobianConfig{T, V, N, D} where D where N where V where T}, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eachindex), Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F))}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94cc145b20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F))}, sparams=svec(), method=eachindex(AbstractArray{T, 1} where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000124f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{NamedTuple{(:stop,), T} where T<:Tuple}, Tuple{ColorTypes.Colorant{T, N} where N where T}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bfe64640)[Core.MethodMatch(spec_types=Tuple{Type{NamedTuple{(:stop,), T} where T<:Tuple}, Tuple{ColorTypes.Colorant{T, N} where N where T}}, sparams=svec((:stop,)), method=(::Type{NamedTuple{names, T} where T<:Tuple})(Tuple) where {names}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000183, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Base.Iterators.Zip{Is} where Is<:Tuple{Any, Base.Iterators.Drop{I} where I}, Tuple{Any, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0a610a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Base.Iterators.Zip{Is} where Is<:Tuple{Any, Base.Iterators.Drop{I} where I}, Tuple{Any, Any}}, sparams=svec(), method=iterate(Base.Iterators.Zip{Is} where Is<:Tuple, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000018c2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:context,), var"#s179"} where var"#s179"<:Tuple{IO}, typeof(Core.invokelatest), typeof(Base.sprint), typeof(Base.show_exception_stack), Base.ExceptionStack}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c54d8920)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:context,), var"#s179"} where var"#s179"<:Tuple{IO}, typeof(Core.invokelatest), typeof(Base.sprint), typeof(Base.show_exception_stack), Base.ExceptionStack}, sparams=svec(), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(Core.invokelatest), Any, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000005d8, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_rule), Type{Tuple{Main.var"#F_linear#cannoles_tests##0", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}, Type}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94ccab3360)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_rule), Type{Tuple{Main.var"#F_linear#cannoles_tests##0", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}, Type{Union{}}}, sparams=svec(Tuple{Main.var"#F_linear#cannoles_tests##0", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}), method=promote_rule(Type{T}, Type{Union{}}, Any...) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_rule), Type{Tuple{Main.var"#F_linear#cannoles_tests##0", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}, Type}, sparams=svec(), method=promote_rule(Type, Type), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000600, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{SparseMatricesCOO.SparseMatrixCOO{Float16, Int64}}, Int64, Int64, Array{Int64, 1}, Array{Int64, 1}, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c2ae1b60)[Core.MethodMatch(spec_types=Tuple{Type{SparseMatricesCOO.SparseMatrixCOO{Float16, Int64}}, Int64, Int64, Array{Int64, 1}, Array{Int64, 1}, Array{Float16, 1}}, sparams=svec(Float16, Int64), method=(::Type{SparseMatricesCOO.SparseMatrixCOO{Tv, Ti}})(Integer, Integer, Array{Ti, 1}, Array{Ti, 1}, Array{Tv, 1}) where {Tv, Ti<:Integer}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ea, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type, Int64}, limit=3), nothing, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{Nothing, Float16, _A}, 1} where _A, Array{Float16, 1}, Any, ForwardDiff.Partials{_A, Float16} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ce4c1180)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{Nothing, Float16, N}, 1}, Array{Float16, 1}, Any, ForwardDiff.Partials{N, Float16}} where N, sparams=svec(Nothing, Float16, N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any, ForwardDiff.Partials{N, V}) where {T, V, N}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, 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.:(var"==")), Tuple{Array{Float16, 1}, Array{Float16, 1}}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c7d44ba0)[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.:(var"==")), Tuple{Array{Float16, 1}, Array{Float16, 1}}, Nothing}, sparams=svec(typeof(Base.:(var"=="))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkindex), Type{Bool}, Any, Int64}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.__cat_offset!), Array{Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}, 1}, Tuple{Int64}, Tuple{Bool}, Tuple{Any}, Vararg{Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94feb44e20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.__cat_offset!), Array{Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}, 1}, Tuple{Int64}, Tuple{Bool}, Tuple{Any}}, sparams=svec(), method=__cat_offset!(Any, Any, Any, Any), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.__cat_offset!), Array{Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}, 1}, Tuple{Int64}, Tuple{Bool}, Tuple{Any}, Any, Vararg{Any}}, sparams=svec(), method=__cat_offset!(Any, Any, Any, Any, Any, Any...), fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000013af, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.require_one_based_indexing), Array{ForwardDiff.Dual{Nothing, Float16, N}, 1} where N, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c1ad53a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.require_one_based_indexing), Array{ForwardDiff.Dual{Nothing, Float16, N}, 1} where N, Array{Float16, 1}}, sparams=svec(), method=require_one_based_indexing(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001235, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Iterators._zip_iterate_some), Tuple{Any, Base.OneTo{Int64}}, Tuple{Tuple{}, Tuple{}}, Tuple{Any, Base.Missing}, Base.Missing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94cb2dfd20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators._zip_iterate_some), Tuple{Any, Base.OneTo{Int64}}, Tuple{Tuple{}, Tuple{}}, Tuple{Base.Missing, Base.Missing}, 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, Base.OneTo{Int64}}, Tuple{Tuple{}, Tuple{}}, Tuple{Any, Base.Missing}, 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=0x00000000000018c7, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), Array{Int64, 1}, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cf2e8ac0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), Array{Int64, 1}, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"}, sparams=svec(), method=combine_styles(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004832, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{ForwardDiff.Dual{T, Float16, _A}} where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), Float16, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c4e9e340)[Core.MethodMatch(spec_types=Tuple{Type{ForwardDiff.Dual{T, Float16, N}}, Float16, ForwardDiff.Partials{N, Float16}} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), Float16, 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=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copy), Any}, limit=3), nothing, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)), Array{Float16, 1}, Any, Tuple{Vararg{ForwardDiff.Partials{N, Float16}, N}} where N, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fdef9c00)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, N}, 1}, Array{Float16, 1}, Any, Tuple{Vararg{ForwardDiff.Partials{N, Float16}, N}}, Int64} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)), sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)), Float16, N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any, Tuple{Vararg{ForwardDiff.Partials{N, V}, N}}, Any) where {T, V, N}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, 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{Array{Float16, 1}, Array{Float16, 1}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ca2f9d00)[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{Array{Float16, 1}, Array{Float16, 1}}}}, sparams=svec(Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(+)), Tuple{Array{Float16, 1}, Array{Float16, 1}}), method=convert(Type{Base.Broadcast.Broadcasted{NewStyle, Axes, F, Args} where Args<:Tuple where F where Axes}, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where var"#s677") where {NewStyle, Axes, F, Args}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047d1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IndexStyle}, Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(>)), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Float16}}}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c2109920)[ Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(>)), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Float16}}}}}}, sparams=svec(), method=(::Type{Base.IndexStyle})(Type{var"#s677"} where var"#s677"<:(Base.Broadcast.Broadcasted{var"#s676", var"#s675", F, Args} where Args<:Tuple where F where var"#s675"<:Tuple{Any} where var"#s676")), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047ea, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Base.OrdinalRange{Int64, Int64}}, Base.OrdinalRange{var"#s677", var"#s676"} where var"#s676"<:Integer where var"#s677"<:Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c893a660)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Base.OrdinalRange{Int64, Int64}}, Base.OrdinalRange{var"#s677", var"#s676"} where var"#s676"<:Integer where var"#s677"<:Integer}, sparams=svec(Base.OrdinalRange{Int64, Int64}), method=convert(Type{T}, Base.AbstractRange{T} where T) where {T<:(Base.AbstractRange{T} where T)}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000875, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:show_time, :x0), Tuple{Bool, Array{Float16, 1}}}, Any, Int64, ADNLPModels.var"#57#58", Int64, ADNLPModels.var"#F!#369"{Main.var"#F_Rosen#cannoles_tests##1", Int64}}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.jac_structure!), Any, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, 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, 0x7f94cec1f3e0)[ Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_structure!), ADNLPModels.SparseADJacobian{Tag, R, T, C, S} where S where C where T where R where Tag, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, Base.SubArray{T, 1, P, I, L} where L where I where P where T<:Integer, Base.SubArray{T, 1, P, I, L} where L where I where P where T<:Integer}, sparams=svec(), method=jac_structure!(ADNLPModels.SparseADJacobian{Tag, R, T, C, S} where S where C where T where R where Tag, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{var"#s103", 1} where var"#s103"<:Integer, AbstractArray{var"#s102", 1} where var"#s102"<:Integer), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_structure!), ADNLPModels.ADBackend, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, Base.SubArray{T, 1, P, I, L} where L where I where P where T<:Integer, Base.SubArray{T, 1, P, I, L} where L where I where P where T<:Integer}, sparams=svec(), method=jac_structure!(ADNLPModels.ADBackend, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{var"#s103", 1} where var"#s103"<:Integer, AbstractArray{var"#s102", 1} where var"#s102"<:Integer), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_structure!), NLPModels.AbstractNLPModel{T, S} where S where T, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, Base.SubArray{T, 1, P, I, L} where L where I where P where T<:Integer, Base.SubArray{T, 1, P, I, L} where L where I where P where T<:Integer}, sparams=svec(), method=jac_structure!(NLPModels.AbstractNLPModel{T, S} where S where T, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{var"#s103", 1} where var"#s103"<:Integer, AbstractArray{var"#s102", 1} where var"#s102"<:Integer), fully_covers=false), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ad, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.LazyString}, Base.LazyString, Base.LazyString}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c059f780)[Core.MethodMatch(spec_types=Tuple{Type{Base.LazyString}, Base.LazyString, Base.LazyString}, sparams=svec(), method=(::Type{Base.LazyString})(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000f1c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_rule), Type, Type{Tuple{Main.var"#F_Rosen#cannoles_tests##1", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}}, limit=3), nothing, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), SparseMatricesCOO.SparseMatrixCOO{Tv, Int64} where Tv}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb9c3080)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), SparseMatricesCOO.SparseMatrixCOO{Tv, Int64} where Tv}, sparams=svec(), method=size(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ea, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.cconvert), Type{Ptr{Float16}}, Memory{Float16}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c40f7220)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.cconvert), Type{Ptr{Float16}}, Memory{Float16}}, sparams=svec(), method=cconvert(Type{var"#s179"} where var"#s179"<:(Ptr{T} where T), GenericMemory{isatomic, T, addrspace} where addrspace where T where isatomic), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c80, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.jac_structure_residual!), NLPModels.AbstractNLPModel{T, S} where S where T, Array{Int64, 1}, Array{Int64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7f94cb039f20)[ Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_structure_residual!), Main.MGH01CON{T, S} where S where T, Array{Int64, 1}, Array{Int64, 1}}, sparams=svec(), method=jac_structure_residual!(Main.MGH01CON{T, S} where S where T, AbstractArray{var"#s4", 1} where var"#s4"<:Integer, AbstractArray{var"#s3", 1} where var"#s3"<:Integer), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_structure_residual!), Main.MGH01_noFHess{T, S} where S where T, Array{Int64, 1}, Array{Int64, 1}}, sparams=svec(), method=jac_structure_residual!(Main.MGH01_noFHess{T, S} where S where T, AbstractArray{var"#s4", 1} where var"#s4"<:Integer, AbstractArray{var"#s3", 1} where var"#s3"<:Integer), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_structure_residual!), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, Array{Int64, 1}, Array{Int64, 1}}, sparams=svec(), method=jac_structure_residual!(ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, AbstractArray{var"#s103", 1} where var"#s103"<:Integer, AbstractArray{var"#s102", 1} where var"#s102"<:Integer), fully_covers=false), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009703, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), ADNLPModels.var"#F!#357"{var"#s179", var"#s179"} where var"#s179"<:Integer where var"#s179"<:Function}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ff7b63a0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), ADNLPModels.var"#F!#357"{var"#s179", var"#s179"} where var"#s179"<:Integer where var"#s179"<:Function}, 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.keys), NamedTuple{names, T} where T<:Tuple where names}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb937680)[Core.MethodMatch(spec_types=Tuple{typeof(Base.keys), NamedTuple{names, T} where T<:Tuple where names}, sparams=svec(names), method=keys(NamedTuple{names, T} where T<:Tuple) where {names}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001aa6, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:(Base.Dict{Symbol, _D} where _D), Base.Dict{Symbol, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7f94ccb715a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Base.Dict{Symbol, Any}}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, Base.Dict{Symbol, Any}} where Base.Dict{Symbol, Any}<:T<:(Base.Dict{Symbol, _D} where _D), sparams=svec(Base.Dict{Symbol, Any}<:T<:(Base.Dict{Symbol, _D} where _D)), method=convert(Type{T}, T) where {T<:(Base.AbstractDict{K, V} where V where K)}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:(Base.Dict{Symbol, _D} where _D), Base.Dict{Symbol, Any}}, sparams=svec(var"#s175"<:(Base.Dict{Symbol, _D} where _D)), method=convert(Type{T}, Base.AbstractDict{K, V} where V where K) where {T<:(Base.AbstractDict{K, V} where V where K)}, fully_covers=true), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000177d, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.collect_to_with_first!), Array{_A, 1} where _A, Any, 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}, _A}} where _A), Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c1f03bc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.collect_to_with_first!), Array{_A, 1} where _A, Any, 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}, _A}} where _A), Int64}, sparams=svec(), method=collect_to_with_first!(AbstractArray{T, N} where N where T, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001105, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(/)), var"#s179"} where var"#s179"<:Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Array{Float16, 1}}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bf474f60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(/)), var"#s179"} where var"#s179"<:Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Array{Float16, 1}}, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s179"} where var"#s179"<:Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Array{Float16, 1}}}, limit=1), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94bed486a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.copyto!), Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s179"} where var"#s179"<:Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Array{Float16, 1}}}, sparams=svec(), method=copyto!(AbstractArray{T, N} where N where T, Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048c4, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Any}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(!=)), Any, Any}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(DiffResults.jacobian), DiffResults.MutableDiffResult{O, V, D} where D<:Tuple where V where O}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cbc39fc0)[Core.MethodMatch(spec_types=Tuple{typeof(DiffResults.jacobian), DiffResults.MutableDiffResult{O, V, D} where D<:Tuple where V where O}, sparams=svec(), method=jacobian(DiffResults.DiffResult{O, V, D} where D<:Tuple where V where O), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009687, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseMatricesCOO.rows), SparseMatricesCOO.SparseMatrixCOO{Tv, Int64} where Tv}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cbc19c40)[Core.MethodMatch(spec_types=Tuple{typeof(SparseMatricesCOO.rows), SparseMatricesCOO.SparseMatrixCOO{Tv, Int64} where Tv}, sparams=svec(), method=rows(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ea, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.map!), Type{ForwardDiff.Dual{_A, V, N} where N where V} where _A, Array{ForwardDiff.Dual{Tag, T, 1}, 1} where T where Tag, Any, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94cab98b20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.map!), F, Array{ForwardDiff.Dual{Tag, T, 1}, 1} where T where Tag, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T} where F<:(Type{ForwardDiff.Dual{_A, V, N} where N where V} where _A), sparams=svec(F<:F<:(Type{ForwardDiff.Dual{_A, V, N} where N where V} where _A)), method=map!(F, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T) where {F}, fully_covers=false), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000014de, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.map), Base.Broadcast.var"#broadcasted##10#broadcasted##11", Tuple{Base.OrdinalRange{Int64, Int64}}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c9a5e3e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.map), Base.Broadcast.var"#broadcasted##10#broadcasted##11", Tuple{Base.OrdinalRange{Int64, Int64}}, Tuple{Int64}}, sparams=svec(), method=map(Any, Tuple{Any}, Tuple{Any}), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006c6, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Iterators.zip), Base.UnitRange{Int64}, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb448d80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators.zip), Base.UnitRange{Int64}, Any}, sparams=svec(), method=zip(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000018a5, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._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.ADNLSModel{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, 0x7f94cc943a40)[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.ADNLSModel{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.ADNLSModel{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=0x00000000000031dc, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A, Array{Float16, 1}, Int64, ForwardDiff.Partials{_A, Float16} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fe0fb300)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, N}, 1}, Array{Float16, 1}, Int64, ForwardDiff.Partials{N, Float16}} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), Float16, N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any, ForwardDiff.Partials{N, V}) where {T, V, N}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ReverseDiff.gradient), Function, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, ReverseDiff.GradientConfig{ReverseDiff.TrackedArray{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bfdf3840)[Core.MethodMatch(spec_types=Tuple{typeof(ReverseDiff.gradient), Function, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, ReverseDiff.GradientConfig{ReverseDiff.TrackedArray{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}}}}, sparams=svec(), method=gradient(Any, Any, ReverseDiff.GradientConfig{I} where I), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.length), Type{SA} where SA<:(StaticArraysCore.StaticArray{S, T, N} where N where T where S<:Tuple)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94fe649aa0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.length), Type{SA} where SA<:(StaticArraysCore.StaticArray{S, T, N} where N where T where S<:Tuple)}, sparams=svec(SA<:(StaticArraysCore.StaticArray{S, T, N} where N where T where S<:Tuple)), method=length(Type{SA}) where {SA<:(Union{LinearAlgebra.Adjoint{T, var"#s5"} where var"#s5"<:Union{StaticArraysCore.StaticArray{Tuple{var"#s2"}, T, 1} where var"#s2", StaticArraysCore.StaticArray{Tuple{var"#s3", var"#s4"}, T, 2} where var"#s4" where var"#s3"}, LinearAlgebra.Diagonal{T, var"#s12"} where var"#s12"<:(StaticArraysCore.StaticArray{Tuple{var"#s13"}, T, 1} where var"#s13"), LinearAlgebra.Hermitian{T, var"#s9"} where var"#s9"<:(StaticArraysCore.StaticArray{Tuple{var"#s10", var"#s11"}, T, 2} where var"#s11" where var"#s10"), LinearAlgebra.LowerTriangular{T, var"#s17"} where var"#s17"<:(StaticArraysCore.StaticArray{Tuple{var"#s18", var"#s19"}, T, 2} where var"#s19" where var"#s18"), LinearAlgebra.Symmetric{T, var"#s6"} where var"#s6"<:(StaticArraysCore.StaticArray{Tuple{var"#s7", var"#s8"}, T, 2} where var"#s8" where var"#s7"), LinearAlgebra.Transpose{T, var"#s1"} where var"#s1"<:Union{StaticArraysCore.StaticArray{Tuple{var"#s2"}, T, 1} where var"#s2", StaticArraysCore.StaticArray{Tuple{var"#s3", var"#s4"}, T, 2} where var"#s4" where var"#s3"}, LinearAlgebra.UnitLowerTriangular{T, var"#s23"} where var"#s23"<:(StaticArraysCore.StaticArray{Tuple{var"#s24", var"#s25"}, T, 2} where var"#s25" where var"#s24"), LinearAlgebra.UnitUpperTriangular{T, var"#s20"} where var"#s20"<:(StaticArraysCore.StaticArray{Tuple{var"#s21", var"#s22"}, T, 2} where var"#s22" where var"#s21"), LinearAlgebra.UpperTriangular{T, var"#s14"} where var"#s14"<:(StaticArraysCore.StaticArray{Tuple{var"#s15", var"#s16"}, T, 2} where var"#s16" where var"#s15"), StaticArraysCore.StaticArray{Tuple{var"#s25"}, T, 1} where var"#s25", StaticArraysCore.StaticArray{Tuple{var"#s4", var"#s3"}, T, 2} where var"#s3" where var"#s4", StaticArraysCore.StaticArray{var"#s25", T, N} where N where var"#s25"<:Tuple} where T)}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009697, max_world=0xffffffffffffffff), ambig=true), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.structural_eachindex), AbstractArray{ForwardDiff.Dual{T, ForwardDiff.Dual{T, V, N}, N}, N} where N where N where T where V where T, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.jac_nln_structure!), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, Array{Int64, 1}, Array{Int64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ce26cea0)[Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_nln_structure!), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, Array{Int64, 1}, Array{Int64, 1}}, sparams=svec(), method=jac_nln_structure!(Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{var"#s103", 1} where var"#s103"<:Integer, AbstractArray{var"#s102", 1} where var"#s102"<:Integer), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ad, 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.:(+)), var"#s179"} where var"#s179"<:Tuple{Array{T, 1} where T<:Integer, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94cb33bb20)[ 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.:(+)), var"#s179"} where var"#s179"<:Tuple{Array{T, 1} where T<:Integer, Int64}}, sparams=svec(), method=materialize!(Base.Broadcast.BitMaskedBitArray{N, M} where M where N, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Any, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(+)), var"#s179"} where var"#s179"<:Tuple{Array{T, 1} where T<:Integer, Int64}}, sparams=svec(), method=materialize!(Any, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000493d, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), Any, ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c354e6a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Base.Broadcast.BroadcastStyle, F, Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}} where F<:(ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F))), sparams=svec(F<:F<:(ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)))), method=broadcasted(Base.Broadcast.BroadcastStyle, F, Any...) where {F}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Any, ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}}, sparams=svec(F), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000495a, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{ForwardDiff.Dual{_A, V, _B}} where _B where V<:(ForwardDiff.Dual{T, V, N} where T where V where N) where _A, Any, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0a5a920)[Core.MethodMatch(spec_types=Tuple{Type{ForwardDiff.Dual{T, V, N}}, ForwardDiff.Dual{T, V, N} where N where V where T, ForwardDiff.Partials{N, V}} where N where V<:(ForwardDiff.Dual{T, V, N} where T where V where N) where T, sparams=svec(T, V, 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=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unwrapva), Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ccf49e00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unwrapva), Any}, sparams=svec(), method=unwrapva(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000036d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_type), Type{Tuple{Function, Function, Array{Float64, 1}, Array{Float64, 1}}}, Type{Tuple{Main.var"#cannoles_tests##22#cannoles_tests##23"{Main.var"#F_larger#cannoles_tests##2"}, Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ff8ff920)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_type), Type{Tuple{Function, Function, Array{Float64, 1}, Array{Float64, 1}}}, Type{Tuple{Main.var"#cannoles_tests##22#cannoles_tests##23"{Main.var"#F_larger#cannoles_tests##2"}, Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}}, sparams=svec(Tuple{Function, Function, Array{Float64, 1}, Array{Float64, 1}}, Tuple{Main.var"#cannoles_tests##22#cannoles_tests##23"{Main.var"#F_larger#cannoles_tests##2"}, Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}), method=promote_type(Type{T}, Type{S}) where {T, S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000005f9, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Array{Tuple{Function, Function, Array{Float64, 1}, Array{Float64, 1}}, 1}, Tuple{Base.UnitRange{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fcb69a60)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Array{Tuple{Function, Function, Array{Float64, 1}, Array{Float64, 1}}, 1}, Tuple{Base.UnitRange{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{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float16, 1}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float16, 1}, Float16}}}}}, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float16, 1}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float16, 1}, Float16}}}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ff97a460)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float16, 1}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float16, 1}, Float16}}}}}, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float16, 1}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float16, 1}, Float16}}}, Tuple{Base.OneTo{Int64}}}, sparams=svec(Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float16, 1}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float16, 1}, Float16}}}), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args}})(Any, Any, Any) where {Style, Axes, F, Args}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b7, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}} where var"#s179"<:Tuple, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94cb7c33e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}} where var"#s179"<:Tuple, Any}, sparams=svec(), method=_broadcast_getindex(Base.Broadcast.Broadcasted{var"#s677", var"#s676", var"#s675", var"#s674"} where var"#s674" where var"#s675" where var"#s676" where var"#s677", Any), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004896, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{ReverseDiff.SkipOptimize{typeof(Base.:(!=))}, ReverseDiff.TrackedReal{V, D, O} where O where D<:Real where V<:Real, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bfe49aa0)[Core.MethodMatch(spec_types=Tuple{ReverseDiff.SkipOptimize{typeof(Base.:(!=))}, ReverseDiff.TrackedReal{V, D, O} where O where D<:Real where V<:Real, Int64}, sparams=svec(typeof(Base.:(!=))), method=(::ReverseDiff.SkipOptimize{F})(Any, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:obj_weight,), Tuple{Float16}}, typeof(NLPModels.hess_coord!), Main.MGH01CON{T, S} where S where T, Array{Float16, 1}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bfe2d560)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:obj_weight,), Tuple{Float16}}, typeof(NLPModels.hess_coord!), Main.MGH01CON{T, S} where S where T, Array{Float16, 1}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(Float16), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(NLPModels.hess_coord!), Main.MGH01CON{T, S} where S where T, AbstractArray{T, 1}, AbstractArray{T, 1} where T) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000970e, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:(SparseMatricesCOO.SparseMatrixCOO{Float16, Ti} where Ti<:Integer), SparseMatricesCOO.SparseMatrixCOO{Float16, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94cca9c6e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, SparseMatricesCOO.SparseMatrixCOO{Float16, Int64}}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:(SparseMatricesCOO.SparseMatrixCOO{Float16, Ti} where Ti<:Integer), SparseMatricesCOO.SparseMatrixCOO{Float16, Int64}}, sparams=svec(), method=convert(Type{var"#s11"} where var"#s11"<:(SparseMatricesCOO.AbstractSparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv), AbstractArray{T, 2} where T), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ea, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseArrays.sparse_check), Integer, Array{Ti, 1} where Ti<:Integer, Array{Ti, 1} where Ti<:Integer, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c9671620)[Core.MethodMatch(spec_types=Tuple{typeof(SparseArrays.sparse_check), Integer, Array{Ti, 1} where Ti<:Integer, Array{Ti, 1} where Ti<:Integer, Array{Float16, 1}}, sparams=svec(Ti<:Integer), method=sparse_check(Integer, Array{Ti, 1}, Any, Any) where {Ti}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009678, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Type{Array{Tuple{Main.var"#cannoles_tests##16#cannoles_tests##17"{Main.var"#F_under#cannoles_tests##7", Int64}, Array{Float64, 1}, Array{Float64, 1}}, 1}}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ce3a3020)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Type{Array{Tuple{Main.var"#cannoles_tests##16#cannoles_tests##17"{Main.var"#F_under#cannoles_tests##7", Int64}, Array{Float64, 1}, Array{Float64, 1}}, 1}}, Symbol}, sparams=svec(), method=getproperty(Type, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000027d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.length), Base.SubArray{T, N, P, I, L} where L where I where P where N where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cdec1520)[Core.MethodMatch(spec_types=Tuple{typeof(Base.length), Base.SubArray{T, N, P, I, L} where L where I where P where N where T}, sparams=svec(), method=length(AbstractArray{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000124c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.preprocess), Array{Float16, 1}, Array{_A, 1} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c4323ec0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.preprocess), Array{Float16, 1}, Array{_A, 1} where _A}, sparams=svec(), method=preprocess(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048cb, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Type{Array{T, 1}} where T, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94fdc976a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Type{Array{T, 1}} where T, Tuple{Base.OneTo{Int64}}}, sparams=svec(T<:(Array{T, 1} where T)), method=similar(Type{T}, Tuple{Union{Integer, Base.OneTo{T} where T<:Integer}, Vararg{Union{Integer, Base.OneTo{T} where T<:Integer}}}) where {T<:(AbstractArray{T, N} where N where T)}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000129c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_rule), Type{Tuple{Main.var"#cannoles_tests##16#cannoles_tests##17"{Main.var"#F_under#cannoles_tests##7", Int64}, Array{Float64, 1}, Array{Float64, 1}}}, Type{Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ca7c9f40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_rule), Type{Tuple{Main.var"#cannoles_tests##16#cannoles_tests##17"{Main.var"#F_under#cannoles_tests##7", Int64}, Array{Float64, 1}, Array{Float64, 1}}}, Type{Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}}}, sparams=svec(), method=promote_rule(Type, Type), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000005fc, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), Base.SubArray{_A, _B, P, I, true} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.identity), Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94cb5e8b60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.SubArray{_A, _B, P, I, true} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.identity), Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}}}, sparams=svec(), method=materialize!(Any, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048be, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.print), Base.GenericIOBuffer{Memory{UInt8}}, Type}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94feabefa0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.print), Base.GenericIOBuffer{Memory{UInt8}}, Type}, sparams=svec(), method=print(IO, Any), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003da3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.real), Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), Base.SubArray{E, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{T, 1} where T<:Union{Float32, Float64}) where E<:Union{Float32, Float64}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, Nothing, typeof(Base.identity), Tuple{Float16}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94cec3d420)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.SubArray{E, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{T, 1} where T<:Union{Float32, Float64}) where E<:Union{Float32, Float64}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, Nothing, typeof(Base.identity), Tuple{Float16}}}, sparams=svec(), method=materialize!(Any, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048be, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:x0,), Tuple{Array{Float64, 1}}}, Any, Int64, ADNLPModels.var"#51#52", Integer, ADNLPModels.var"#F!#369"{var"#s179", var"#s179"} where var"#s179"<:Integer where var"#s179"<:Function}, limit=3), nothing, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.jac_nln_structure!), NLPModels.AbstractNLPModel{T, S} where S where T, 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=(2,), mem=Memory{Any}(4, 0x7f94ce344ea0)[ Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_nln_structure!), Main.MGH01CON{T, S} where S where T, Base.SubArray{T, 1, P, I, L} where L where I where P where T<:Integer, Base.SubArray{T, 1, P, I, L} where L where I where P where T<:Integer}, sparams=svec(), method=jac_nln_structure!(Main.MGH01CON{T, S} where S where T, AbstractArray{var"#s4", 1} where var"#s4"<:Integer, AbstractArray{var"#s3", 1} where var"#s3"<:Integer), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_nln_structure!), Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, Base.SubArray{T, 1, P, I, L} where L where I where P where T<:Integer, Base.SubArray{T, 1, P, I, L} where L where I where P where T<:Integer}, sparams=svec(), method=jac_nln_structure!(Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{var"#s103", 1} where var"#s103"<:Integer, AbstractArray{var"#s102", 1} where var"#s102"<:Integer), fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009714, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.LinearIndices{N, R} where R<:Tuple{Vararg{Base.AbstractUnitRange{Int64}, N}} where N}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cd2b5fa0)[Core.MethodMatch(spec_types=Tuple{Type{Base.LinearIndices{N, R} where R<:Tuple{Vararg{Base.AbstractUnitRange{Int64}, N}} where N}, Tuple{Base.OneTo{Int64}}}, sparams=svec(1, Tuple{Base.OneTo{Int64}}), method=(::Type{Base.LinearIndices{N, R} where R where N})(R) where {N, R<:Tuple{Vararg{Base.AbstractUnitRange{Int64}, N}}}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000100e, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.increment!), ADNLPModels.ADNLSModel{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, 0x7f94c04c2e40)[Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.increment!), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, Base.Val{:neval_cons_nln}}, sparams=svec(), method=increment!(NLPModels.AbstractNLSModel{T, S} where S where T, Base.Val{:neval_cons_nln}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096aa, 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{Float16, 1}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fd571f20)[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{Float16, 1}}}}, sparams=svec(Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), Tuple{Array{Float16, 1}}), method=convert(Type{Base.Broadcast.Broadcasted{NewStyle, Axes, F, Args} where Args<:Tuple where F where Axes}, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where var"#s677") where {NewStyle, Axes, F, Args}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047d1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Fix{1, F, T} where T where F}, Type{Base.MappingRF{F, T} where T where F}, Base.var"#_bool##0#_bool##1"{Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.iszero)}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fe16b200)[Core.MethodMatch(spec_types=Tuple{Type{Base.Fix{1, F, T} where T where F}, Type{Base.MappingRF{F, T} where T where F}, Base.var"#_bool##0#_bool##1"{Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.iszero)}}}, sparams=svec(1, UnionAll), method=(::Type{Base.Fix{N, F, T} where T where F})(F, Any) where {N, F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c46, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Type{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fe099980)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Type{Int64}}, sparams=svec(Int64), method=getindex(Type{T}, Any...) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010bd, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{Bool}, Tuple{Int64}}}} where var"#s179"<:Tuple, LinearAlgebra.BandIndex}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94cc907de0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{Bool}, Tuple{Int64}}}} where var"#s179"<:Tuple, LinearAlgebra.BandIndex}, sparams=svec(), method=_broadcast_getindex(Base.Broadcast.Broadcasted{var"#s677", var"#s676", var"#s675", var"#s674"} where var"#s674" where var"#s675" where var"#s676" where var"#s677", Any), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004896, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{ft} where ft<:Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer})}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94beab5260)[Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer})}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000034c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.chunk_mode_gradient), ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A, ForwardDiff.GradientConfig{T, ForwardDiff.Dual{T, V, N}, N, DG} where DG where N where V where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ff03c720)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.chunk_mode_gradient), ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A, ForwardDiff.GradientConfig{T, ForwardDiff.Dual{T, V, N}, N, DG} where DG where N where V where T}, sparams=svec(F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c), T, V<:(ForwardDiff.Dual{T, V, N} where T where V where N), N), method=chunk_mode_gradient(F, Any, ForwardDiff.GradientConfig{T, V, N, D} where D) where {F, T, V, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.call_composed), Tuple{Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{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)}}}, Tuple{Base.BottomRF{typeof(Base.add_sum)}}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ce17dbe0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.call_composed), Tuple{Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{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)}}}, Tuple{Base.BottomRF{typeof(Base.add_sum)}}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}}, sparams=svec(), method=call_composed(Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c2c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{LinearAlgebra.MulAddMul{true, true, Bool, Bool}}, Bool, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0576180)[Core.MethodMatch(spec_types=Tuple{Type{LinearAlgebra.MulAddMul{true, true, Bool, Bool}}, Bool, Bool}, sparams=svec(), method=(::Type{LinearAlgebra.MulAddMul{ais1, bis0, TA, TB}})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000007bba, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.vector_mode_dual_eval!), ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c, ForwardDiff.GradientConfig{T, ForwardDiff.Dual{T, V, N}, N, DG} where DG where N where V where T, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ffe437e0)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.vector_mode_dual_eval!), ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c, ForwardDiff.GradientConfig{T, ForwardDiff.Dual{T, V, N}, N, DG} where DG where N where V where T, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A}, sparams=svec(F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)), method=vector_mode_dual_eval!(F, Union{ForwardDiff.GradientConfig{T, V, N, D} where D where N where V where T, ForwardDiff.JacobianConfig{T, V, N, D} where D where N where V where T}, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Float16}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ceab2060)[Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Float16}, Int64}, sparams=svec(Float16), method=convert(Type{T}, Number) where {T<:Number}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000a40, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{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}, Int64}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f9500944b60)[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}, Int64}, Nothing}, sparams=svec(typeof(Base.:(/))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), Array{Float16, 1}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R}}, limit=1), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94fea360e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.copyto!), Array{Float16, 1}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R}}, sparams=svec(), method=copyto!(AbstractArray{T, N} where N where T, Base.Broadcast.Broadcasted{Nothing, Axes, F, Args} where Args<:Tuple where F where Axes), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048d0, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), SparseMatricesCOO.SparseMatrixCOO{Float16, Ti} where Ti<:Integer, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ce486920)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), SparseMatricesCOO.SparseMatrixCOO{Float16, Ti} where Ti<:Integer, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c8a33320)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"}, sparams=svec(), method=materialize!(Any, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Any}, sparams=svec(), method=materialize!(Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048be, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_type), Type{Bool}, Type{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c7c41360)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_type), Type{Bool}, Type{Int64}}, sparams=svec(Bool, Int64), method=promote_type(Type{T}, Type{S}) where {T, S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000005f9, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_result), Type{Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}}, Type{Tuple{Main.var"#cannoles_tests##16#cannoles_tests##17"{Main.var"#F_under#cannoles_tests##7", Int64}, Array{Float64, 1}, Array{Float64, 1}}}, Type{Union{}}, Type{Union{}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ca7cab00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_result), Type{Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}}, Type{Tuple{Main.var"#cannoles_tests##16#cannoles_tests##17"{Main.var"#F_under#cannoles_tests##7", Int64}, Array{Float64, 1}, Array{Float64, 1}}}, Type{Union{}}, Type{Union{}}}, sparams=svec(Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}, Tuple{Main.var"#cannoles_tests##16#cannoles_tests##17"{Main.var"#F_under#cannoles_tests##7", Int64}, Array{Float64, 1}, Array{Float64, 1}}), method=promote_result(Type{T}, Type{S}, Type{Union{}}, Type{Union{}}) where {T, S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000603, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), Array{T, 1} where T<:(ForwardDiff.Dual{T, V, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A) where _A)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb4e42c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), Array{T, 1} where T<:(ForwardDiff.Dual{T, V, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A) where _A)}, sparams=svec(), method=size(Array{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001093, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex_widen_up_to), Array{_A, 1} where _A, Any, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c314cc60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex_widen_up_to), Array{_A, 1} where _A, Any, Int64}, sparams=svec(_A), method=setindex_widen_up_to(AbstractArray{T, N} where N, Any, Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001108, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_type), Type, Type{Tuple{Main.var"#F_Rosen#cannoles_tests##1", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7f94ccaedf60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_type), Type{Union{}}, Type{Tuple{Main.var"#F_Rosen#cannoles_tests##1", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}}, sparams=svec(Tuple{Main.var"#F_Rosen#cannoles_tests##1", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}), method=promote_type(Type{Union{}}, Type{T}) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_type), Type{Tuple{Main.var"#F_Rosen#cannoles_tests##1", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}, Type{Tuple{Main.var"#F_Rosen#cannoles_tests##1", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}}, sparams=svec(Tuple{Main.var"#F_Rosen#cannoles_tests##1", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}), method=promote_type(Type{T}, Type{T}) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_type), Type, Type{Tuple{Main.var"#F_Rosen#cannoles_tests##1", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}}, sparams=svec(T, Tuple{Main.var"#F_Rosen#cannoles_tests##1", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}), method=promote_type(Type{T}, Type{S}) where {T, S}, fully_covers=true), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000005f9, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Int64}, UInt64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c1067140)[Core.MethodMatch(spec_types=Tuple{Type{Int64}, UInt64}, sparams=svec(), method=(::Type{Int64})(Union{Bool, Int128, Int16, Int32, Int64, Int8, UInt128, UInt16, UInt32, UInt64, UInt8}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000217, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{UInt8}, Char}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bffa1be0)[Core.MethodMatch(spec_types=Tuple{Type{UInt8}, Char}, sparams=svec(), method=(::Type{Int8})(Char), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003652, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A, Array{Float16, 1}, Tuple{Vararg{ForwardDiff.Partials{_A, Float16}, _A}} where _A, ForwardDiff.Partials{_A, Float16} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c40c37c0)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, N}, 1}, Array{Float16, 1}, Tuple{Vararg{ForwardDiff.Partials{_A, Float16}, _A}} where _A, ForwardDiff.Partials{N, Float16}} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), Float16, N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any, ForwardDiff.Partials{N, V}) where {T, V, N}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.zeros), Any, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c268bbe0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.zeros), Type{T}, Int64} where T, sparams=svec(T), method=zeros(Type{T}, Union{Integer, Base.AbstractUnitRange{T} where T}...) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.zeros), Union{Integer, Base.AbstractUnitRange{T} where T}, Int64}, sparams=svec(), method=zeros(Union{Integer, Base.AbstractUnitRange{T} where T}...), fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010d0, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c26988e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Int64}, sparams=svec(), method=checkbounds(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Integer), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004886, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{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.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fd195ac0)[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.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}}, sparams=svec(typeof(Base.:(-))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b1, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Any, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A, Any, Tuple{Vararg{ForwardDiff.Partials{N, ForwardDiff.Dual{T, V, N}}, N}} where N where V where T, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bff5dc00)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), AbstractArray{ForwardDiff.Dual{T, ForwardDiff.Dual{T, V, N}, N}, N} where N, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A, Any, Tuple{Vararg{ForwardDiff.Partials{N, ForwardDiff.Dual{T, V, N}}, N}}, Any} where N where T where V where T, sparams=svec(T, V<:(ForwardDiff.Dual{T, V, N} where T where V where N), N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any, Tuple{Vararg{ForwardDiff.Partials{N, V}, N}}, Any) where {T, V, N}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), Array{T, 1} where T<:(ForwardDiff.Dual{T, V, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A) where _A)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fea4af00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), Array{T, 1} where T<:(ForwardDiff.Dual{T, V, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A) where _A)}, sparams=svec(), method=size(Array{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001093, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), Tuple{Array{Float16, 1}}}}, typeof(Base.identity), Tuple{Array{Float16, 1}}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fd55e520)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), Tuple{Array{Float16, 1}}}}, typeof(Base.identity), Tuple{Array{Float16, 1}}, Tuple{Base.OneTo{Int64}}}, sparams=svec(Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), Tuple{Array{Float16, 1}}), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args}})(Any, Any, Any) where {Style, Axes, F, Args}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b7, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcast_unalias), Base.SubArray{_A, _B, P, I, true} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c3f8bb40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcast_unalias), Base.SubArray{_A, _B, P, I, true} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A, Array{Float16, 1}}, sparams=svec(), method=broadcast_unalias(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048c7, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{StaticArraysCore.Size{S} where S}, Type{StaticArraysCore.SArray{Tuple{1}, _A, N, L} where L where N} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94fe8f64e0)[ Core.MethodMatch(spec_types=Tuple{Type{StaticArraysCore.Size{S} where S}, Type{StaticArraysCore.SArray{Tuple{1}, _A, N, L} where L where N} where _A}, sparams=svec(Tuple{1}, SA<:(StaticArraysCore.SArray{Tuple{1}, _A, N, L} where L where N where _A)), method=(::Type{StaticArraysCore.Size{S} where S})(Type{SA}) where {S<:Tuple, SA<:(StaticArraysCore.StaticArray{S, T, N} where N where T)}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009686, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.SubArray{Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}, 1, Array{Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}, 1}, Tuple{Base.UnitRange{Int64}}, true}}, Array{Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}, 1}, Tuple{Base.UnitRange{Int64}}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c809ef60)[Core.MethodMatch(spec_types=Tuple{Type{Base.SubArray{Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}, 1, Array{Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}, 1}, Tuple{Base.UnitRange{Int64}}, true}}, Array{Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}, 1}, Tuple{Base.UnitRange{Int64}}, Int64, Int64}, sparams=svec(Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}, 1, Array{Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}, 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=0x0000000000002d90, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_rule), Type{Tuple{Main.var"#F_Rosen#cannoles_tests##1", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}, Type}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94ccaefe60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_rule), Type{Tuple{Main.var"#F_Rosen#cannoles_tests##1", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}, Type{Union{}}}, sparams=svec(Tuple{Main.var"#F_Rosen#cannoles_tests##1", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}), method=promote_rule(Type{T}, Type{Union{}}, Any...) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_rule), Type{Tuple{Main.var"#F_Rosen#cannoles_tests##1", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}, Type}, sparams=svec(), method=promote_rule(Type, Type), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000600, 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}}, ReverseDiff.TrackedStyle, typeof(Base.:(>)), Tuple{Array{Int64, 1}, Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fdc5d5a0)[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}}, ReverseDiff.TrackedStyle, typeof(Base.:(>)), Tuple{Array{Int64, 1}, Real}}, sparams=svec(typeof(Base.:(>))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unaliascopy), Array{_A, 1} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c43919e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unaliascopy), Array{_A, 1} where _A}, sparams=svec(), method=unaliascopy(Array{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000130b, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Array{Float16, 1}}, UndefInitializer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0fd8800)[Core.MethodMatch(spec_types=Tuple{Type{Array{Float16, 1}}, UndefInitializer, Int64}, sparams=svec(Float16), 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.Broadcast.broadcasted), Base.Broadcast.DefaultArrayStyle{0}, typeof(Base.:(-)), Base.OrdinalRange{Int64, Int64}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c94ed220)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Base.Broadcast.DefaultArrayStyle{0}, typeof(Base.:(-)), Base.OrdinalRange{Int64, Int64}, Int64}, sparams=svec(typeof(Base.:(-))), method=broadcasted(Base.Broadcast.BroadcastStyle, F, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000495a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Printf.base), Type{Base.Val{Char(0x64000000)}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cc72c1e0)[Core.MethodMatch(spec_types=Tuple{typeof(Printf.base), Type{Base.Val{Char(0x64000000)}}}, sparams=svec(), method=base(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000967e, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.map), Base.IteratorsMD.var"#CartesianIndices##0#CartesianIndices##1", Tuple{Base.OrdinalRange{var"#s677", var"#s676"} where var"#s676"<:Integer where var"#s677"<:Integer}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bea718c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.map), Base.IteratorsMD.var"#CartesianIndices##0#CartesianIndices##1", Tuple{Base.OrdinalRange{var"#s677", var"#s676"} where var"#s676"<:Integer where var"#s677"<:Integer}}, sparams=svec(), method=map(Any, Tuple{Any}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006bc, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eltype), Type{NamedTuple{(:verbose,), Tuple{Int64}}}}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c28e6060)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.eltype), Type{NamedTuple{(:verbose,), Tuple{Int64}}}}, sparams=svec(NamedTuple{(:verbose,), Tuple{Int64}}), method=eltype(Type{T}) where {T<:(NamedTuple{names, T} where T<:Tuple where names)}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001a7a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A, Array{Float16, 1}, Int64, Tuple{Vararg{ForwardDiff.Partials{_A, Float16}, _A}} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c01e1160)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, N}, 1}, Array{Float16, 1}, Int64, Tuple{Vararg{ForwardDiff.Partials{N, Float16}, N}}} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:Function), sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:Function), Float16, N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any, Tuple{Vararg{ForwardDiff.Partials{N, V}, N}}) where {T, V, N}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Array{Float16, 1}, Any, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94bf21e560)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Array{Float16, 1}, Type{T}, Int64} where T, 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=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Array{Float16, 1}, Union{Integer, Base.AbstractUnitRange{T} where T}, Int64}, sparams=svec(Float16), method=similar(AbstractArray{T, N} where N, Union{Integer, Base.AbstractUnitRange{T} where T}...) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001290, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Iterators._zip_isdone), Tuple{Any, Base.OneTo{Int64}}, Tuple{Tuple{}, Tuple{}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cbf8b720)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators._zip_isdone), Tuple{Any, Base.OneTo{Int64}}, Tuple{Tuple{}, Tuple{}}}, sparams=svec(), method=_zip_isdone(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000018ce, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{TypeVar}, Any, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cd0e99c0)[Core.MethodMatch(spec_types=Tuple{Type{TypeVar}, Any, Any}, sparams=svec(), method=(::Type{TypeVar})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000003d, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ADNLPModels.get_nln_nnzh), 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}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fe6ce420)[Core.MethodMatch(spec_types=Tuple{typeof(ADNLPModels.get_nln_nnzh), 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}, sparams=svec(), method=get_nln_nnzh(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), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ad, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.require_one_based_indexing), Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb6eba40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.require_one_based_indexing), Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), Array{Float16, 1}}, sparams=svec(), method=require_one_based_indexing(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001235, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._reindexlinear), Base.SubArray{Any, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{T, 1} where T<:Union{Float32, Float64}), Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cd7eab80)[Core.MethodMatch(spec_types=Tuple{typeof(Base._reindexlinear), Base.SubArray{Any, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{T, 1} where T<:Union{Float32, Float64}), 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, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002e00, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Iterators._zip_iterate_interleave), Tuple{Any, Tuple{Int64, Int64}}, Tuple{}, Tuple{Any, Base.Missing}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94cb403e60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators._zip_iterate_interleave), Tuple{Any, Tuple{Int64, Int64}}, Tuple{}, Tuple{Bool, Base.Missing}}, sparams=svec(), method=_zip_iterate_interleave(Any, Any, Tuple{Bool, Vararg{Any}}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators._zip_iterate_interleave), Tuple{Any, Tuple{Int64, Int64}}, Tuple{}, Tuple{Any, Base.Missing}}, sparams=svec(), method=_zip_iterate_interleave(Any, Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000018cb, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eachindex), Base.IndexLinear, Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)), Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94ff0522e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), Base.IndexLinear, Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)), Array{Float16, 1}}, sparams=svec(), method=eachindex(Base.IndexLinear, AbstractArray{T, N} where N where T, (AbstractArray{T, N} where N where T)...), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000125b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.rem), Int64, Type{UInt8}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0d974c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.rem), Int64, Type{UInt8}}, sparams=svec(), method=rem(Int64, Type{UInt8}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000b3c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{NamedTuple{(:x0, :ncon, :y0, :lcon, :ucon, :nnzj, :nnzh, :nln_nnzj, :name, :minimize), T} where T<:Tuple}, Tuple{Array{Float16, 1}, Int64, Array{Float16, 1}, Array{Float16, 1}, Array{Float16, 1}, Any, Any, Any, String, Bool}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0dc07a0)[Core.MethodMatch(spec_types=Tuple{Type{NamedTuple{(:x0, :ncon, :y0, :lcon, :ucon, :nnzj, :nnzh, :nln_nnzj, :name, :minimize), T} where T<:Tuple}, Tuple{Array{Float16, 1}, Int64, Array{Float16, 1}, Array{Float16, 1}, Array{Float16, 1}, Any, Any, Any, String, Bool}}, sparams=svec((:x0, :ncon, :y0, :lcon, :ucon, :nnzj, :nnzh, :nln_nnzj, :name, :minimize)), method=(::Type{NamedTuple{names, T} where T<:Tuple})(Tuple) where {names}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000183, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Int64}, UInt128}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c8b6d460)[Core.MethodMatch(spec_types=Tuple{Type{Int64}, UInt128}, sparams=svec(), method=(::Type{Int64})(Union{Bool, Int128, Int16, Int32, Int64, Int8, UInt128, UInt16, UInt32, UInt64, UInt8}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000217, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Array{Float16, 1}, Type{Float16}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c47df740)[Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Array{Float16, 1}, Type{Float16}, Tuple{Int64}}, sparams=svec(1), method=similar(Array{T, N} where N where T, Type, Tuple{Vararg{Int64, N}}) where {N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010b8, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Base.Iterators.Take{I} where I}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cc456680)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Base.Iterators.Take{I} where I}, sparams=svec(), method=iterate(Base.Iterators.Take{I} where I), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001931, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c448c760)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Int64}, sparams=svec(1), method=getindex(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Vararg{Union{Integer, Base.IteratorsMD.CartesianIndex{N} where N}, N}) where {N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000487c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), ColorTypes.ComponentIterator{C} where C<:Union{ColorTypes.AlphaColor{Cb, T, N} where Cb<:Union{ColorTypes.HSI{T} where T<:AbstractFloat, ColorTypes.HSL{T} where T<:AbstractFloat, ColorTypes.HSV{T} where T<:AbstractFloat, ColorTypes.LCHab{T} where T<:AbstractFloat, ColorTypes.LCHuv{T} where T<:AbstractFloat, ColorTypes.Oklch{T} where T<:AbstractFloat}, ColorTypes.ColorAlpha{Cb, T, N} where Cb<:Union{ColorTypes.HSI{T} where T<:AbstractFloat, ColorTypes.HSL{T} where T<:AbstractFloat, ColorTypes.HSV{T} where T<:AbstractFloat, ColorTypes.LCHab{T} where T<:AbstractFloat, ColorTypes.LCHuv{T} where T<:AbstractFloat, ColorTypes.Oklch{T} where T<:AbstractFloat}, ColorTypes.HSI{T} where T<:AbstractFloat, ColorTypes.HSL{T} where T<:AbstractFloat, ColorTypes.HSV{T} where T<:AbstractFloat, ColorTypes.LCHab{T} where T<:AbstractFloat, ColorTypes.LCHuv{T} where T<:AbstractFloat, ColorTypes.Oklch{T} where T<:AbstractFloat} where N where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bff0d980)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), ColorTypes.ComponentIterator{C}} where C<:(ColorTypes.Colorant{T, N} where T) where N, sparams=svec(N, C<:(ColorTypes.Colorant{T, N} where T)), method=iterate(ColorTypes.ComponentIterator{C}) where {N, C<:(ColorTypes.Colorant{T, N} where T)}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096d6, 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"#s179", typeof(Base.identity), Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}} where var"#s179"<:Tuple}, limit=1), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c8bd9c20)[ 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"#s179", typeof(Base.identity), Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}} where var"#s179"<:Tuple}, sparams=svec(), method=copyto!(AbstractArray{T, N} where N where T, Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048c4, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Array{Float16, 1}}, UndefInitializer, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cc753a20)[Core.MethodMatch(spec_types=Tuple{Type{Array{Float16, 1}}, UndefInitializer, Tuple{Int64}}, sparams=svec(Float16), 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.materialize!), Any, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.identity), Tuple{Base.BitArray{1}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94ca97ef60)[ 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.identity), Tuple{Base.BitArray{1}}}}, sparams=svec(), method=materialize!(Base.Broadcast.BitMaskedBitArray{N, M} where M where N, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Any, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.identity), Tuple{Base.BitArray{1}}}}, sparams=svec(), method=materialize!(Any, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000493d, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(-)), Tuple{Vararg{ForwardDiff.Partials{_A, Float16}, _A}} where _A, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(0,), mem=Memory{Any}(0, 0x7f9509e33d90)[]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000000, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{ForwardDiff.Tag{F, V} where V where F}, ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F, Type{Float16}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c25f0d20)[Core.MethodMatch(spec_types=Tuple{Type{ForwardDiff.Tag{F, V} where V where F}, ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F, Type{Float16}}, sparams=svec(F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F), Float16), method=(::Type{ForwardDiff.Tag{F, V} where V where F})(F, Type{V}) where {F, V}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#__cat_offset1!##0#__cat_offset1!##1"{Tuple{Int64}, Tuple{Bool}, var"#s179", _A} where _A where var"#s179"<:Tuple{Any}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c428a8c0)[Core.MethodMatch(spec_types=Tuple{Base.var"#__cat_offset1!##0#__cat_offset1!##1"{Tuple{Int64}, Tuple{Bool}, var"#s179", _A} where _A where var"#s179"<:Tuple{Any}, Int64}, sparams=svec(), method=(::Base.var"#__cat_offset1!##0#__cat_offset1!##1"{shape, catdims, offsets, x})(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000013b5, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.cons_nln!), ADNLPModels.ADNLSModel{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, 0x7f94c0471320)[Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.cons_nln!), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T}, sparams=svec(), method=cons_nln!(Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ad, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isbitstype), Type{Float16}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c831b640)[Core.MethodMatch(spec_types=Tuple{typeof(Base.isbitstype), Type{Float16}}, sparams=svec(), method=isbitstype(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000503, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.ndims), Type{Float16}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c9aeabc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.ndims), Type{Float16}}, sparams=svec(), method=ndims(Type{var"#s179"} where var"#s179"<:Number), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000a4d, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.require_one_based_indexing), Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:Function), Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c07bb2e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.require_one_based_indexing), Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:Function), Array{Float16, 1}}, sparams=svec(), method=require_one_based_indexing(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001235, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_rule), Type{Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}}, Type{Tuple{Main.var"#cannoles_tests##16#cannoles_tests##17"{Main.var"#F_under#cannoles_tests##7", Int64}, Array{Float64, 1}, Array{Float64, 1}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ca7c9160)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_rule), Type{Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}}, Type{Tuple{Main.var"#cannoles_tests##16#cannoles_tests##17"{Main.var"#F_under#cannoles_tests##7", Int64}, Array{Float64, 1}, Array{Float64, 1}}}}, sparams=svec(), method=promote_rule(Type, Type), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000005fc, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), Base.SubArray{E, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{T, 1} where T<:Union{Float32, Float64}) where E<:Union{Float32, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cd527260)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), Base.SubArray{E, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{T, 1} where T<:Union{Float32, Float64}) where E<:Union{Float32, Float64}}, sparams=svec(), method=combine_styles(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004830, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eachindex), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c2ab6120)[Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}}, sparams=svec(), method=eachindex(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047e3, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(var"==")), Tuple, Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c255e2a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.:(var"==")), Tuple, Tuple}, sparams=svec(), method=var"=="(Tuple, Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000070d, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Array{T, 1}} where T<:(ForwardDiff.Dual{T, V, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A) where _A), UndefInitializer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb489720)[Core.MethodMatch(spec_types=Tuple{Type{Array{T, 1}} where T<:(ForwardDiff.Dual{T, V, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A) where _A), UndefInitializer, Int64}, sparams=svec(T<:(ForwardDiff.Dual{T, V, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) 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{typeof(NLPModels.jac_structure!), Any, ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7f94cf906920)[ Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_structure!), ADNLPModels.SparseADJacobian{Tag, R, T, C, S} where S where C where T where R where Tag, ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(), method=jac_structure!(ADNLPModels.SparseADJacobian{Tag, R, T, C, S} where S where C where T where R where Tag, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{var"#s103", 1} where var"#s103"<:Integer, AbstractArray{var"#s102", 1} where var"#s102"<:Integer), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_structure!), ADNLPModels.ADBackend, ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(), method=jac_structure!(ADNLPModels.ADBackend, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{var"#s103", 1} where var"#s103"<:Integer, AbstractArray{var"#s102", 1} where var"#s102"<:Integer), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_structure!), NLPModels.AbstractNLPModel{T, S} where S where T, ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(), method=jac_structure!(NLPModels.AbstractNLPModel{T, S} where S where T, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{var"#s103", 1} where var"#s103"<:Integer, AbstractArray{var"#s102", 1} where var"#s102"<:Integer), fully_covers=false), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ad, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.rem), Int64, Any}, limit=3), nothing, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(+)), Tuple{Array{Float16, 1}, Array{Float16, 1}}}}, typeof(Base.:(+)), Tuple{Array{Float16, 1}, Array{Float16, 1}}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ca304d80)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(+)), Tuple{Array{Float16, 1}, Array{Float16, 1}}}}, typeof(Base.:(+)), Tuple{Array{Float16, 1}, Array{Float16, 1}}, Tuple{Base.OneTo{Int64}}}, sparams=svec(Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(+)), Tuple{Array{Float16, 1}, Array{Float16, 1}}), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args}})(Any, Any, Any) where {Style, Axes, F, Args}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.call_composed), 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.ADNLSModel{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)}}}, Tuple{Base.BottomRF{typeof(Base.add_sum)}}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ce14b160)[Core.MethodMatch(spec_types=Tuple{typeof(Base.call_composed), 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.ADNLSModel{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)}}}, Tuple{Base.BottomRF{typeof(Base.add_sum)}}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}}, sparams=svec(), method=call_composed(Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c2c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.SubArray{Any, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{T, 1} where T<:Union{Float32, Float64}), Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cd7e9aa0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.SubArray{Any, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{T, 1} where T<:Union{Float32, Float64}), Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IndexStyle}, Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}} where var"#s179"<:Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fd958120)[Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}} where var"#s179"<:Tuple}, sparams=svec(), method=(::Type{Base.IndexStyle})(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047e9, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{NamedTuple{(:dims,), T} where T<:Tuple}, Tuple{Base.Val{1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ca8f3e40)[Core.MethodMatch(spec_types=Tuple{Type{NamedTuple{(:dims,), T} where T<:Tuple}, Tuple{Base.Val{1}}}, sparams=svec((:dims,)), method=(::Type{NamedTuple{names, T} where T<:Tuple})(Tuple) where {names}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000183, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ADNLPModels.get_residual_nnzh), 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}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c404b760)[ Core.MethodMatch(spec_types=Tuple{typeof(ADNLPModels.get_residual_nnzh), ADNLPModels.ADModelBackend{GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS}, Any} where HBLS<:(NLPModels.AbstractNLPModel{T, S} where S where T) where JBLS where JtvBLS where JvBLS where HvBLS where GHJ where HB where JB where JtvB where JvB where HvB where GB, sparams=svec(GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS<:(NLPModels.AbstractNLPModel{T, S} where S where T)), method=get_residual_nnzh(ADNLPModels.ADModelBackend{GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS}, Any) where {GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS<:(NLPModels.AbstractNLPModel{T, S} where S where T)}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(ADNLPModels.get_residual_nnzh), 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}, sparams=svec(), method=get_residual_nnzh(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), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ad, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.has_offset_axes), Array{ForwardDiff.Dual{Nothing, Float16, N}, 1} where N}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c1ad77a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.has_offset_axes), Array{ForwardDiff.Dual{Nothing, Float16, N}, 1} where N}, sparams=svec(), method=has_offset_axes(Array{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001232, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.first), Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.check_parent_index_match), Array{Float16, 1}, Tuple{Array{T, 1} where T<:Integer}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bfd3db00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.check_parent_index_match), Array{Float16, 1}, Tuple{Array{T, 1} where T<:Integer}}, sparams=svec(), method=check_parent_index_match(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002d95, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c39672e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"}, sparams=svec(), method=materialize!(Any, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Any}, sparams=svec(), method=materialize!(Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048be, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.view), AbstractArray{T, 1} where T, Array{Int64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94caee3e60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.view), FillArrays.AbstractFill{T, 1, Axes} where Axes where T, Array{Int64, 1}}, sparams=svec(), method=view(FillArrays.AbstractFill{T, N, Axes} where Axes where N where T, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.view), AbstractArray{T, 1} where T, Array{Int64, 1}}, sparams=svec(1), method=view(AbstractArray{T, N} where N where T, Vararg{Any, M}) where {M}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000967a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(&)), Any, Any}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.print_to_string), String, Type{StaticArraysCore.SArray{Tuple{2}, _A, N, L} where L where N} where _A, String, Int64, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c4d76820)[Core.MethodMatch(spec_types=Tuple{typeof(Base.print_to_string), String, Type{StaticArraysCore.SArray{Tuple{2}, _A, N, L} where L where N} where _A, String, Int64, String}, sparams=svec(), method=print_to_string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003dae, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isinf), Any}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.gradient), ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A, ForwardDiff.GradientConfig{T, ForwardDiff.Dual{T, V, N}, N, DG} where DG where N where V where T, Base.Val{false}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c477f380)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.gradient), ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A, ForwardDiff.GradientConfig{T, ForwardDiff.Dual{T, V, N}, N, DG} where DG where N where V where T, Base.Val{false}}, sparams=svec(F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F), T, false), method=gradient(F, AbstractArray{T, N} where N where T, ForwardDiff.GradientConfig{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=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A))}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c8c53cc0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A))}, sparams=svec(), method=Typeof(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000028, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.map!), Type{ForwardDiff.Dual{_A, V, N} where N where V} where _A, Array{ForwardDiff.Dual{Tag, T, 1}, 1} where T where Tag, AbstractArray{T, 1} where T, Base.BitArray{1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94cbd064a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.map!), Type{ForwardDiff.Dual{_A, V, N} where N where V} where _A, Array{ForwardDiff.Dual{Tag, T, 1}, 1} where T where Tag, AbstractArray{T, 1} where T, Base.BitArray{1}}, sparams=svec(F<:(Type{ForwardDiff.Dual{_A, V, N} where N where V} where _A)), method=map!(F, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000014de, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.hessian), ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c262c020)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.hessian), ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F, Array{Float16, 1}}, sparams=svec(F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), method=hessian(F, AbstractArray{T, N} where N where T) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), Tuple{Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c8c50560)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), Tuple{Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}}}, sparams=svec(F<:(ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} 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) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b1, 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.identity), Tuple{Float16}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ceed0060)[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.identity), Tuple{Float16}, 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=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.axes1), Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:Function)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c080b260)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.axes1), Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:Function)}, sparams=svec(), method=axes1(AbstractArray{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001237, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eps), Any}, limit=3), nothing, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{Nothing, Float16, N}, 1} where N, Array{Float16, 1}, Int64, Tuple{Vararg{ForwardDiff.Partials{N, Float16}, N}} where N, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cf22d6c0)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{Nothing, Float16, N}, 1}, Array{Float16, 1}, Int64, Tuple{Vararg{ForwardDiff.Partials{N, Float16}, N}}, Int64} where N, sparams=svec(Nothing, Float16, N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any, Tuple{Vararg{ForwardDiff.Partials{N, V}, N}}, Any) where {T, V, N}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.hess_structure!), NLPModels.AbstractNLPModel{T, S} where S where T, Array{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, 0x7f94cb3455a0)[ Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.hess_structure!), Main.MGH01CON{T, S} where S where T, Array{Int64, 1}, Array{Int64, 1}}, sparams=svec(), method=hess_structure!(Main.MGH01CON{T, S} where S where T, AbstractArray{Int64, 1}, AbstractArray{Int64, 1}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.hess_structure!), Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, Array{T, 1} where T<:Integer, Array{T, 1} where T<:Integer}, sparams=svec(), method=hess_structure!(Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{var"#s103", 1} where var"#s103"<:Integer, AbstractArray{var"#s102", 1} where var"#s102"<:Integer), fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000970a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Array{_A, 1} where _A}, limit=1), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94caed8960)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.copyto!), Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, 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=0x00000000000012ab, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(*)), Float16, SparseMatricesCOO.SparseMatrixCOO{Float16, Ti} where Ti<:Integer, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c3397b60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.:(*)), Float16, SparseMatricesCOO.SparseMatrixCOO{Float16, Ti} where Ti<:Integer, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(), method=*(Union{Real, Base.Complex{T} where T<:Real}, AbstractArray{var"#s4713", 2} where var"#s4713"<:Union{Real, Base.Complex{T} where T<:Real}, AbstractArray{var"#s4712", 1} where var"#s4712"<:Union{Real, Base.Complex{T} where T<:Real}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000007f62, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unalias), Array{_A, 1} where _A, Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c2b75f00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unalias), Array{_A, 1} where _A, Real}, sparams=svec(), method=unalias(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001309, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), Array{T, 1} where T<:(ForwardDiff.Dual{T, V, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A) where _A), Array{ForwardDiff.Dual{T, V, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A) where _A}, limit=1), nothing, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.chunk_mode_jacobian), Any, Array{Float16, 1}, ForwardDiff.JacobianConfig{Nothing, Float16, _A, Array{ForwardDiff.Dual{Nothing, Float16, _A}, 1}} where _A where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c1b14ae0)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.chunk_mode_jacobian), Any, Array{Float16, 1}, ForwardDiff.JacobianConfig{Nothing, Float16, _A, Array{ForwardDiff.Dual{Nothing, Float16, _A}, 1}} where _A where _A}, sparams=svec(F, Nothing, Float16, _A), method=chunk_mode_jacobian(F, Any, ForwardDiff.JacobianConfig{T, V, N, D} where D) where {F, T, V, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Array{T, 1}} where T<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A), UndefInitializer, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c29ee080)[Core.MethodMatch(spec_types=Tuple{Type{Array{T, 1}} where T<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A), UndefInitializer, Tuple{Int64}}, sparams=svec(T<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A)), 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(Core.Typeof), ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F))}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c4770220)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F))}, 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.Generator{I, F} where F where I}, Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##0#__cat_offset1!##1"{Tuple{Int64}, Tuple{Bool}, Tuple{Int64}, Tuple{Main.var"#F_Rosen#cannoles_tests##1", Main.var"#c_linear#cannoles_tests##10", Array{Float64, 1}, Array{Float64, 1}}}}, Base.UnitRange{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c3454520)[Core.MethodMatch(spec_types=Tuple{Type{Base.Generator{I, F} where F where I}, Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##0#__cat_offset1!##1"{Tuple{Int64}, Tuple{Bool}, Tuple{Int64}, Tuple{Main.var"#F_Rosen#cannoles_tests##1", Main.var"#c_linear#cannoles_tests##10", Array{Float64, 1}, Array{Float64, 1}}}}, Base.UnitRange{Int64}}, sparams=svec(Base.UnitRange{Int64}, Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##0#__cat_offset1!##1"{Tuple{Int64}, Tuple{Bool}, Tuple{Int64}, Tuple{Main.var"#F_Rosen#cannoles_tests##1", Main.var"#c_linear#cannoles_tests##10", Array{Float64, 1}, Array{Float64, 1}}}}), method=(::Type{Base.Generator{I, F} where F where I})(F, I) where {I, F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000420, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.preprocess), Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c83603e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.preprocess), Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), var"#s179"} where var"#s179"<:Tuple{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=0x00000000000048ca, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N where N where V where T, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A, Any, ForwardDiff.Partials{N, V} where V where N}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fd551a80)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A, Any, ForwardDiff.Partials{N, V}} where N where V where T, sparams=svec(T, V, N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any, ForwardDiff.Partials{N, V}) where {T, V, N}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.throw_boundserror), Array{ForwardDiff.Dual{T, Float16, N}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where N, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c3ad5880)[Core.MethodMatch(spec_types=Tuple{typeof(Base.throw_boundserror), Array{ForwardDiff.Dual{T, Float16, N}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where N, Tuple{Int64}}, sparams=svec(), method=throw_boundserror(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000310, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.sizehint!), Base.Dict{Symbol, V} where V, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb7f5ca0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.sizehint!), Base.Dict{Symbol, V} where V, Int64}, sparams=svec(Symbol), method=sizehint!(Base.Dict{T, V} where V, Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000034cd, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Array{T, 1}} where T<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A), UndefInitializer, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb29dd00)[Core.MethodMatch(spec_types=Tuple{Type{Array{T, 1}} where T<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A), UndefInitializer, Tuple{Int64}}, sparams=svec(T<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A)), 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(Core.kwcall), NamedTuple{(:show_time, :x0), Tuple{Bool, Array{Float64, 1}}}, Any, Int64, ADNLPModels.var"#18#19", Int64, ADNLPModels.var"#22#23"}, limit=3), nothing, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), Base.Broadcast.DefaultArrayStyle{1}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.identity), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c85c1880)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.Broadcast.DefaultArrayStyle{1}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.identity), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R}}, sparams=svec(), method=materialize!(Base.Broadcast.BroadcastStyle, Any, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048bf, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Type{Bool}, Base.SubArray{Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}, 1, Array{Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}, 1}, Tuple{Base.UnitRange{Int64}}, true}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94cd447f60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Type{Bool}, Base.SubArray{Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}, 1, Array{Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}, 1}, Tuple{Base.UnitRange{Int64}}, true}, Int64}, sparams=svec(), method=checkbounds(Type{Bool}, AbstractArray{T, N} where N where T, Any), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000127a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.map!), ForwardDiff.var"#extract_value!##0#extract_value!##1"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), Any, AbstractArray{T, N} where N where T}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.any), Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcast), typeof(Base.:(>)), Array{Int64, 1}, Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(6, 0x7f94ca357040)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcast), typeof(Base.:(>)), Array{Int64, 1}, ReverseDiff.TrackedReal{V, D, O} where O where D<:Real where V<:Real}, sparams=svec(), method=broadcast(typeof(Base.:(>)), Array{T, 1} where T, ReverseDiff.TrackedReal{V, D, O} where O where D<:Real where V<:Real), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcast), typeof(Base.:(>)), Array{Int64, 1}, Real}, sparams=svec(typeof(Base.:(>))), method=broadcast(Tf, Any...) where {Tf}, fully_covers=true), #, #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a1, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:linsolve, :method), Tuple{Symbol, Symbol}}, Type{CaNNOLeS.CaNNOLeSSolver{Ti, T, V, F, M} where M where F where V where T where Ti}, ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cfb6afa0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:linsolve, :method), Tuple{Symbol, Symbol}}, Type{CaNNOLeS.CaNNOLeSSolver{Ti, T, V, F, M} where M where F where V where T where Ti}, ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T}, sparams=svec(T, S), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, Type{CaNNOLeS.CaNNOLeSSolver{Ti, T, V, F, M} where M where F where V where T where Ti}, NLPModels.AbstractNLSModel{T, V}) where {T, V}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096eb, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.:(/)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(*)), Tuple{Array{Float64, 1}, Float64}}, Float64}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cfa54bc0)[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.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(*)), Tuple{Array{Float64, 1}, Float64}}, Float64}, Tuple{Base.OneTo{Int64}}}, sparams=svec(typeof(Base.:(/))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(6, 0x7f94c39c2690)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), Union{}}, Int64}, sparams=svec(T, S), method=_broadcast_getindex(Base.Broadcast.Broadcasted{var"#s677", var"#s676", var"#s675", var"#s674"} where var"#s674"<:Tuple{Ref{Type{T}}, Ref{Type{S}}, Vararg{Any}} where var"#s675" where var"#s676" where var"#s677", Any) where {T, S}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Int64}, sparams=svec(), method=_broadcast_getindex(Base.Broadcast.Broadcasted{var"#s677", var"#s676", var"#s675", var"#s674"} where var"#s674" where var"#s675" where var"#s676" where var"#s677", Any), fully_covers=true), #, #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004899, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eltype), Type{NamedTuple{(:x, :verbose), Tuple{Array{Float16, 1}, Int64}}}}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94ca7abb60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.eltype), Type{NamedTuple{(:x, :verbose), Tuple{Array{Float16, 1}, Int64}}}}, sparams=svec(NamedTuple{(:x, :verbose), Tuple{Array{Float16, 1}, Int64}}), method=eltype(Type{T}) where {T<:(NamedTuple{names, T} where T<:Tuple where names)}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001a7a, 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, 0x7f95004c9440)[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=0x0000000000003db1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{NamedTuple{(:x0,), T} where T<:Tuple}, Tuple{Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fd3f8480)[Core.MethodMatch(spec_types=Tuple{Type{NamedTuple{(:x0,), T} where T<:Tuple}, Tuple{Any}}, sparams=svec((:x0,)), method=(::Type{NamedTuple{names, T} where T<:Tuple})(Tuple) where {names}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000183, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Any, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fe35bc00)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A} where N where V where T, sparams=svec(T, V, N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any) where {T, V, N}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c269ac80)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Tuple{Int64}}, sparams=svec(), method=(::Type{BoundsError})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000005f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Nothing, typeof(Base.:(var"==")), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c8746f40)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Nothing, typeof(Base.:(var"==")), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}, Tuple{Base.OneTo{Int64}}}, sparams=svec(typeof(Base.:(var"=="))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{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, 0x7f94fe6f0400)[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=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.:(*)), Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Float16}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c04d35c0)[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.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Float16}, Tuple{Base.OneTo{Int64}}}, sparams=svec(typeof(Base.:(*))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.dotgetproperty), CaNNOLeS.CaNNOLeSSolver{Ti, Float16, Array{Float16, 1}, CaNNOLeS.MA57Struct, M} where M<:CaNNOLeS.HessianStruct{Ti} where Ti<:Integer, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fe497f40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.dotgetproperty), CaNNOLeS.CaNNOLeSSolver{Ti, Float16, Array{Float16, 1}, CaNNOLeS.MA57Struct, M} where M<:CaNNOLeS.HessianStruct{Ti} where Ti<:Integer, Symbol}, sparams=svec(), method=dotgetproperty(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000286, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N where N where V where T, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A, ForwardDiff.Partials{N, V} where V where N, ForwardDiff.Partials{N, V} where V where N}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ff8fcd80)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A, ForwardDiff.Partials{N, V} where V where N, ForwardDiff.Partials{N, V}} where N where V where T, sparams=svec(T, V, N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any, ForwardDiff.Partials{N, V}) where {T, V, N}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, 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"#s179"} where var"#s179"<:Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Array{Float16, 1}}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bf575d40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s179"} where var"#s179"<:Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Array{Float16, 1}}, Tuple{Base.OneTo{Int64}}}, sparams=svec(), method=_axes(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047da, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.keys), NamedTuple{(:x0, :nnzh, :name, :minimize), var"#s179"} where var"#s179"<:Tuple{Array{Float64, 1}, Any, String, Bool}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fe13d7a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.keys), NamedTuple{(:x0, :nnzh, :name, :minimize), var"#s179"} where var"#s179"<:Tuple{Array{Float64, 1}, Any, String, Bool}}, sparams=svec((:x0, :nnzh, :name, :minimize)), method=keys(NamedTuple{names, T} where T<:Tuple) where {names}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001aa6, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Memory{Symbol}}, UndefInitializer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ff8a0d20)[Core.MethodMatch(spec_types=Tuple{Type{Memory{Symbol}}, UndefInitializer, Int64}, sparams=svec(Symbol, Core.AddrSpace{Core}(0x00), :not_atomic), method=(::Type{GenericMemory{kind, T, addrspace}})(UndefInitializer, Int64) where {T, addrspace, kind}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000100, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eltype), Type{Tuple{Int64}}}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c290a620)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.eltype), Type{Tuple{Int64}}}, sparams=svec(Int64), method=eltype(Type{var"#s179"} where var"#s179"<:Tuple{Vararg{E}}) where {E}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006a8, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Array{Int64, 1}, Real}, typeof(DataType), Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c481ac60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Array{Int64, 1}, Real}, 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"#s179"} where var"#s179"<:Tuple{Array{Int64, 1}, Real}, typeof(DataType), 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=0x00000000000047d5, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.jacobian), Any, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c2d07940)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.jacobian), Any, Array{Float16, 1}}, 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=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ReverseDiff.jacobian!), Array{Float16, 2}, ReverseDiff.JacobianTape{F, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, _A} where _A where F<:Function, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bf165780)[Core.MethodMatch(spec_types=Tuple{typeof(ReverseDiff.jacobian!), Array{Float16, 2}, ReverseDiff.JacobianTape{F, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, _A} where _A where F<:Function, Array{Float16, 1}}, sparams=svec(), method=jacobian!(Any, Union{ReverseDiff.CompiledTape{T} where T<:(ReverseDiff.JacobianTape{F, I, O} where O where I where F), ReverseDiff.JacobianTape{F, I, O} where O where I where F}, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto_axcheck!), Array{T, 1} where T<:(ForwardDiff.Dual{Nothing, Float16, _A} where _A), Array{ForwardDiff.Dual{Nothing, Float16, _A}, 1} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c232e7a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.copyto_axcheck!), Array{T, 1} where T<:(ForwardDiff.Dual{Nothing, Float16, _A} where _A), Array{ForwardDiff.Dual{Nothing, Float16, _A}, 1} where _A}, sparams=svec(), method=copyto_axcheck!(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012b7, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eltype), Type{NamedTuple{(:x0,), Tuple{Array{Float16, 1}}}}}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94cccd01a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.eltype), Type{NamedTuple{(:x0,), Tuple{Array{Float16, 1}}}}}, sparams=svec(NamedTuple{(:x0,), Tuple{Array{Float16, 1}}}), method=eltype(Type{T}) where {T<:(NamedTuple{names, T} where T<:Tuple where names)}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001a7a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isbitstype), Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c8afd2e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.isbitstype), Any}, sparams=svec(), method=isbitstype(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000503, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.reduce_empty_iter), Base.MappingRF{F, T} where T<:Function where F<:Function, Array{Float16, 1}, Base.HasEltype}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c13dbfc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.reduce_empty_iter), Base.MappingRF{F, T} where T<:Function where F<:Function, Array{Float16, 1}, Base.HasEltype}, sparams=svec(), method=reduce_empty_iter(Any, Any, Base.HasEltype), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000324b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{ForwardDiff.GradientConfig{T, V, _A, Array{ForwardDiff.Dual{T, V, _A}, 1}}} where _A where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A) where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A) where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), Any, Array{ForwardDiff.Dual{T, V, _A}, 1} where _A where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A) where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F))}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c40b0240)[Core.MethodMatch(spec_types=Tuple{Type{ForwardDiff.GradientConfig{T, V, _A, Array{ForwardDiff.Dual{T, V, _A}, 1}}} where _A where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A) where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A) where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), Any, Array{ForwardDiff.Dual{T, V, _A}, 1} where _A where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A) where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F))}, sparams=svec(), method=(::Type{ForwardDiff.GradientConfig{T, V, N, D}})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c24fef00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.has_offset_axes), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ffe68b20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.has_offset_axes), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A}, sparams=svec(), method=has_offset_axes(Array{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001232, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A, Array{Float16, 1}, Tuple{Vararg{ForwardDiff.Partials{_A, Float16}, _A}} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c087d4a0)[ Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, N}, 1}, Array{Float16, 1}, Tuple{Vararg{ForwardDiff.Partials{N, Float16}, N}}} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:Function), sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:Function), Float16, 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{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A, Array{Float16, 1}, Tuple{Vararg{ForwardDiff.Partials{_A, Float16}, _A}} where _A}, sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:Function), Float16, _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=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{ConcurrencyViolationError}, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c1076e20)[Core.MethodMatch(spec_types=Tuple{Type{ConcurrencyViolationError}, String}, sparams=svec(), method=(::Type{ConcurrencyViolationError})(AbstractString), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000078, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.argtail), Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bec66140)[Core.MethodMatch(spec_types=Tuple{typeof(Base.argtail), Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Array{Float16, 1}}, sparams=svec(), method=argtail(Any, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000035b, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Colors._weighted_color_mean), Float64, Union{ColorTypes.AlphaColor{Cb, T, N} where N where T, ColorTypes.ColorAlpha{Cb, T, N} where N where T, ColorTypes.HSI{T} where T<:AbstractFloat, ColorTypes.HSL{T} where T<:AbstractFloat, ColorTypes.HSV{T} where T<:AbstractFloat, ColorTypes.LCHab{T} where T<:AbstractFloat, ColorTypes.LCHuv{T} where T<:AbstractFloat, ColorTypes.Oklch{T} where T<:AbstractFloat} where Cb<:Union{ColorTypes.HSI{T} where T<:AbstractFloat, ColorTypes.HSL{T} where T<:AbstractFloat, ColorTypes.HSV{T} where T<:AbstractFloat, ColorTypes.LCHab{T} where T<:AbstractFloat, ColorTypes.LCHuv{T} where T<:AbstractFloat, ColorTypes.Oklch{T} where T<:AbstractFloat}, Union{ColorTypes.AlphaColor{Cb, T, N} where N where T, ColorTypes.ColorAlpha{Cb, T, N} where N where T, ColorTypes.HSI{T} where T<:AbstractFloat, ColorTypes.HSL{T} where T<:AbstractFloat, ColorTypes.HSV{T} where T<:AbstractFloat, ColorTypes.LCHab{T} where T<:AbstractFloat, ColorTypes.LCHuv{T} where T<:AbstractFloat, ColorTypes.Oklch{T} where T<:AbstractFloat} where Cb<:Union{ColorTypes.HSI{T} where T<:AbstractFloat, ColorTypes.HSL{T} where T<:AbstractFloat, ColorTypes.HSV{T} where T<:AbstractFloat, ColorTypes.LCHab{T} where T<:AbstractFloat, ColorTypes.LCHuv{T} where T<:AbstractFloat, ColorTypes.Oklch{T} where T<:AbstractFloat}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bfeadea0)[Core.MethodMatch(spec_types=Tuple{typeof(Colors._weighted_color_mean), Float64, Union{ColorTypes.AlphaColor{Cb, T, N} where N where T, ColorTypes.ColorAlpha{Cb, T, N} where N where T, ColorTypes.HSI{T} where T<:AbstractFloat, ColorTypes.HSL{T} where T<:AbstractFloat, ColorTypes.HSV{T} where T<:AbstractFloat, ColorTypes.LCHab{T} where T<:AbstractFloat, ColorTypes.LCHuv{T} where T<:AbstractFloat, ColorTypes.Oklch{T} where T<:AbstractFloat} where Cb<:Union{ColorTypes.HSI{T} where T<:AbstractFloat, ColorTypes.HSL{T} where T<:AbstractFloat, ColorTypes.HSV{T} where T<:AbstractFloat, ColorTypes.LCHab{T} where T<:AbstractFloat, ColorTypes.LCHuv{T} where T<:AbstractFloat, ColorTypes.Oklch{T} where T<:AbstractFloat}, Union{ColorTypes.AlphaColor{Cb, T, N} where N where T, ColorTypes.ColorAlpha{Cb, T, N} where N where T, ColorTypes.HSI{T} where T<:AbstractFloat, ColorTypes.HSL{T} where T<:AbstractFloat, ColorTypes.HSV{T} where T<:AbstractFloat, ColorTypes.LCHab{T} where T<:AbstractFloat, ColorTypes.LCHuv{T} where T<:AbstractFloat, ColorTypes.Oklch{T} where T<:AbstractFloat} where Cb<:Union{ColorTypes.HSI{T} where T<:AbstractFloat, ColorTypes.HSL{T} where T<:AbstractFloat, ColorTypes.HSV{T} where T<:AbstractFloat, ColorTypes.LCHab{T} where T<:AbstractFloat, ColorTypes.LCHuv{T} where T<:AbstractFloat, ColorTypes.Oklch{T} where T<:AbstractFloat}}, sparams=svec(T1, T2), method=_weighted_color_mean(Real, ColorTypes.Colorant{T1, N} where N, ColorTypes.Colorant{T2, N} where N) where {T1, T2}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096e4, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.check_broadcast_axes), Tuple{Base.OneTo{Int64}}, Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bf4b6500)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.check_broadcast_axes), Tuple{Base.OneTo{Int64}}, Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}}, sparams=svec(), method=check_broadcast_axes(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004864, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{SparseArrays.SparseMatrixCSC{Tv, Ti} where Ti<:Integer where Tv}, Integer, Integer, Array{Ti, 1} where Ti<:Integer, Array{Ti, 1} where Ti<:Integer, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c9669960)[Core.MethodMatch(spec_types=Tuple{Type{SparseArrays.SparseMatrixCSC{Tv, Ti} where Ti<:Integer where Tv}, Integer, Integer, Array{Ti, 1} where Ti<:Integer, Array{Ti, 1} where Ti<:Integer, Array{Float16, 1}}, 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=0x0000000000009678, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), LinearAlgebra.Symmetric{Float16, SparseArrays.SparseMatrixCSC{Float16, Ti}} where Ti<:Integer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cabbafc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), LinearAlgebra.Symmetric{Float16, SparseArrays.SparseMatrixCSC{Float16, Ti}} where Ti<:Integer, Int64}, sparams=svec(Float16, 2), method=size(AbstractArray{T, N}, Any) where {T, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001228, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Nothing, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(>)), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Float16}}}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ca696160)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Nothing, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(>)), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Float16}}}, Tuple{Base.OneTo{Int64}}}, sparams=svec(typeof(Base.:(&))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._setindex!), Array{ForwardDiff.Dual{Tagψ, T, 1}, 1} where T where Tagψ, ForwardDiff.Dual{Tagψ, T, 1} where Tagψ where T, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cc1e0a20)[Core.MethodMatch(spec_types=Tuple{typeof(Base._setindex!), Array{ForwardDiff.Dual{Tagψ, T, 1}, 1}, ForwardDiff.Dual{Tagψ, T, 1}, Int64} where Tagψ where T, sparams=svec(T<:(ForwardDiff.Dual{Tagψ, T, 1} where Tagψ where T)), method=_setindex!(Array{T, N} where N, T, Int64) where {T}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001118, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.BitArray{N} where N}, UndefInitializer, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c7fc34e0)[Core.MethodMatch(spec_types=Tuple{Type{Base.BitArray{N} where N}, UndefInitializer, Tuple{Int64}}, sparams=svec(1), method=(::Type{Base.BitArray{N} where N})(UndefInitializer, Tuple{Vararg{Integer, N}}) where {N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001599, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Array{Float16, 2}}, UndefInitializer, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bf7773c0)[Core.MethodMatch(spec_types=Tuple{Type{Array{Float16, 2}}, UndefInitializer, Int64, Int64}, sparams=svec(Float16), method=(::Type{Array{T, 2}})(UndefInitializer, Int64, Int64) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000118, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), Base.Broadcast.DefaultArrayStyle{1}, Array{ForwardDiff.Dual{Tagψ, T, 1}, 1} where T where Tagψ, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.identity), Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cf7d7260)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.Broadcast.DefaultArrayStyle{1}, Array{ForwardDiff.Dual{Tagψ, T, 1}, 1} where T where Tagψ, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.identity), Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}}}, sparams=svec(), method=materialize!(Base.Broadcast.BroadcastStyle, Any, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048bf, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Array{Float16, 1}, Base.LinearIndices{1, Tuple{Base.OneTo{Int64}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0872260)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Array{Float16, 1}, 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{Type{Base.IndexStyle}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fdb8f0c0)[Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{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=0x00000000000047e9, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fe2d30a0)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}}, Tuple{Int64}}, sparams=svec(), method=(::Type{BoundsError})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000005f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Any, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ADNLPModels.get_residual_nnzj), ADNLPModels.ADModelBackend{_A, _B, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, _C, ADNLPModels.EmptyADbackend, _D, _E, _F, _G, _H} where _H where _G where _F where _E where _D where _C where _B where _A, Int64, Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c3e336e0)[ Core.MethodMatch(spec_types=Tuple{typeof(ADNLPModels.get_residual_nnzj), ADNLPModels.ADModelBackend{GB, HvB, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, HB, ADNLPModels.EmptyADbackend, HvBLS, JvBLS, JtvBLS, JBLS, HBLS}, Int64, Integer} where HBLS where JBLS<:(NLPModels.AbstractNLPModel{T, S} where S where T) where JtvBLS where JvBLS where HvBLS where HB where HvB where GB, sparams=svec(GB, HvB, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, HB, ADNLPModels.EmptyADbackend, HvBLS, JvBLS, JtvBLS, JBLS<:(NLPModels.AbstractNLPModel{T, S} where S where T), HBLS), method=get_residual_nnzj(ADNLPModels.ADModelBackend{GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS}, Any, Any) where {GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS<:(NLPModels.AbstractNLPModel{T, S} where S where T), HBLS}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(ADNLPModels.get_residual_nnzj), ADNLPModels.ADModelBackend{_A, _B, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, _C, ADNLPModels.EmptyADbackend, _D, _E, _F, _G, _H} where _H where _G where _F where _E where _D where _C where _B where _A, Int64, Integer}, sparams=svec(), method=get_residual_nnzj(ADNLPModels.ADModelBackend{GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS} where HBLS where JBLS where JtvBLS where JvBLS where HvBLS where GHJ where HB where JB where JtvB where JvB where HvB where GB, Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ad, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.jacobian), Any, Array{Float16, 1}, ForwardDiff.JacobianConfig{Nothing, Float16, _A, Array{ForwardDiff.Dual{Nothing, Float16, _A}, 1}} where _A where _A, Base.Val{true}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c1a107c0)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.jacobian), Any, Array{Float16, 1}, ForwardDiff.JacobianConfig{Nothing, Float16, _A, Array{ForwardDiff.Dual{Nothing, Float16, _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=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Array{Float16, 1}, Type{Float16}, Tuple{Int64, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bf775d00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Array{Float16, 1}, Type{Float16}, Tuple{Int64, Int64}}, sparams=svec(2), method=similar(Array{T, N} where N where T, Type, Tuple{Vararg{Int64, N}}) where {N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010b8, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ReverseDiff.hessian), Function, Array{Float16, 1}, ReverseDiff.HessianConfig{ReverseDiff.GradientConfig{ReverseDiff.TrackedArray{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}}}, ReverseDiff.JacobianConfig{ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, Nothing}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c8f27260)[Core.MethodMatch(spec_types=Tuple{typeof(ReverseDiff.hessian), Function, Array{Float16, 1}, ReverseDiff.HessianConfig{ReverseDiff.GradientConfig{ReverseDiff.TrackedArray{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}}}, ReverseDiff.JacobianConfig{ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, Nothing}}}, sparams=svec(), method=hessian(Any, AbstractArray{T, N} where N where T, ReverseDiff.HessianConfig{G, J} where J<:(ReverseDiff.JacobianConfig{I, O} where O where I) where G<:(ReverseDiff.GradientConfig{I} where I)), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a1, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.view), AbstractArray{T, N} where N where T, Any}, limit=3), nothing, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.to_indices), Array{Float16, 1}, Tuple{Base.OneTo{Int64}}, Tuple{Array{Ti, 1} where Ti<:Integer}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94bef64e60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.to_indices), Array{Float16, 1}, Tuple{Base.OneTo{Int64}}, Tuple{Array{Bool, 1}}}, sparams=svec(1), method=to_indices(Any, Any, Tuple{AbstractArray{Bool, N}, Vararg}) where {N}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.to_indices), Array{Float16, 1}, Tuple{Base.OneTo{Int64}}, Tuple{Array{Ti, 1} where Ti<:Integer}}, sparams=svec(), method=to_indices(Any, Any, Tuple{Any, Vararg}), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000046b1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Tuple{Function, Function, Array{Float64, 1}, Array{Float64, 1}}}, Tuple{Main.var"#F_linear#cannoles_tests##0", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ca93f640)[Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Tuple{Function, Function, Array{Float64, 1}, Array{Float64, 1}}}, Tuple{Main.var"#F_linear#cannoles_tests##0", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}, sparams=svec(Tuple{Function, Function, Array{Float64, 1}, Array{Float64, 1}}), method=convert(Type{T}, T) where {T<:Tuple}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000373, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Array{Float16, 1}, Tuple{Int64, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cacdebc0)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Array{Float16, 1}, 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{typeof(Base.eachindex), Array{_A, 1} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c8a0c360)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), Array{_A, 1} where _A}, sparams=svec(), method=eachindex(AbstractArray{T, 1} where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000124f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(StaticArrays._no_precise_size), Type{StaticArraysCore.SArray{Tuple{1}, _A, N, L} where L where N} where _A, Tuple{Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c54db700)[Core.MethodMatch(spec_types=Tuple{typeof(StaticArrays._no_precise_size), Type{StaticArraysCore.SArray{Tuple{1}, _A, N, L} where L where N} where _A, Tuple{Float64}}, sparams=svec(), method=_no_precise_size(Any, Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009697, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.jac_nln_structure!), NLPModels.AbstractNLPModel{T, S} where S where T, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94ccb43a60)[ Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_nln_structure!), Main.MGH01CON{T, S} where S where T, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(), method=jac_nln_structure!(Main.MGH01CON{T, S} where S where T, AbstractArray{var"#s4", 1} where var"#s4"<:Integer, AbstractArray{var"#s3", 1} where var"#s3"<:Integer), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_nln_structure!), Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(), method=jac_nln_structure!(Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{var"#s103", 1} where var"#s103"<:Integer, AbstractArray{var"#s102", 1} where var"#s102"<:Integer), fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009714, 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{_A, 1} where _A), Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c44f9a60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A), 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=0x0000000000004892, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), AbstractArray{T, 1} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c09c1560)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), AbstractArray{T, 1} where T}, sparams=svec(), method=combine_styles(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004830, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.SubString{T} where T<:AbstractString}, AbstractString, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94cc25bd20)[ Core.MethodMatch(spec_types=Tuple{Type{Base.SubString{T} where T<:AbstractString}, Base.SubString{T} where T<:AbstractString, Int64, Int64}, sparams=svec(), method=(::Type{Base.SubString{T} where T<:AbstractString})(Base.SubString{T} where T<:AbstractString, Int64, Int64), fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{Base.SubString{T} where T<:AbstractString}, AbstractString, Int64, Int64}, sparams=svec(T<:AbstractString), method=(::Type{Base.SubString{T} where T<:AbstractString})(T, Int64, Int64) where {T<:AbstractString}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003764, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Tuple{Vararg{ForwardDiff.Partials{N, ForwardDiff.Dual{T, V, N}}, N}} where N where V where T, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cc3dbaa0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Tuple{Vararg{ForwardDiff.Partials{N, ForwardDiff.Dual{T, V, N}}, N}} where N where V where T, Int64}, sparams=svec(), method=getindex(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000669, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Base.Broadcast.Broadcasted{Nothing, Axes, F, Args} where Args<:Tuple where F where Axes}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, var"#s179", typeof(Base.identity), Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}} where var"#s179"<:Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb73e4c0)[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"#s179", typeof(Base.identity), Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}} where var"#s179"<:Tuple}, sparams=svec(Nothing, var"#s179"<:Tuple, typeof(Base.identity), Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}), method=convert(Type{Base.Broadcast.Broadcasted{NewStyle, Axes, F, Args} where Args<:Tuple where F where Axes}, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where var"#s677") where {NewStyle, Axes, F, Args}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047d1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{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.ADNLSModel{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, 0x7f94ce11a2e0)[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.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64}} where Si where S where T}, sparams=svec(), method=unwrap_composed(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c2a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{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.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(>)), Tuple{Array{Float16, 1}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), Tuple{Array{Float16, 1}, Float16}}}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), Tuple{Array{Float16, 1}, Array{Float16, 1}}}}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c53bc760)[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.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(>)), Tuple{Array{Float16, 1}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), Tuple{Array{Float16, 1}, Float16}}}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), Tuple{Array{Float16, 1}, Array{Float16, 1}}}}, Tuple{Base.OneTo{Int64}}}, sparams=svec(typeof(Base.:(&))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Generator{I, F} where F where I}, Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##0#__cat_offset1!##1"{Tuple{Int64}, Tuple{Bool}, Tuple{Int64}, Tuple{Main.var"#cannoles_tests##12#cannoles_tests##13"{Main.var"#F_larger#cannoles_tests##2", Int64}, Array{Float64, 1}, Array{Float64, 1}}}}, Base.UnitRange{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ca924620)[Core.MethodMatch(spec_types=Tuple{Type{Base.Generator{I, F} where F where I}, Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##0#__cat_offset1!##1"{Tuple{Int64}, Tuple{Bool}, Tuple{Int64}, Tuple{Main.var"#cannoles_tests##12#cannoles_tests##13"{Main.var"#F_larger#cannoles_tests##2", Int64}, Array{Float64, 1}, Array{Float64, 1}}}}, Base.UnitRange{Int64}}, sparams=svec(Base.UnitRange{Int64}, Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##0#__cat_offset1!##1"{Tuple{Int64}, Tuple{Bool}, Tuple{Int64}, Tuple{Main.var"#cannoles_tests##12#cannoles_tests##13"{Main.var"#F_larger#cannoles_tests##2", Int64}, Array{Float64, 1}, Array{Float64, 1}}}}), method=(::Type{Base.Generator{I, F} where F where I})(F, I) where {I, F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000420, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.prevfloat), Any}, 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}}, Nothing, typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}, Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c40e2280)[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{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}, Tuple}, sparams=svec(typeof(Base.identity)), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}} where var"#s179"<:Tuple, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7f94cb7c3260)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}} where var"#s179"<:Tuple, LinearAlgebra.BandIndex}, sparams=svec(), method=checkbounds(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, LinearAlgebra.BandIndex), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}} where var"#s179"<:Tuple, Integer}, sparams=svec(), method=checkbounds(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Integer), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}} where var"#s179"<:Tuple, Base.IteratorsMD.CartesianIndex{N} where N}, sparams=svec(), method=checkbounds(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Base.IteratorsMD.CartesianIndex{N} where N), fully_covers=false), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000007ac1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{ForwardDiff.Tag{F, Float16}} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ffadbf80)[Core.MethodMatch(spec_types=Tuple{Type{ForwardDiff.Tag{F, Float16}} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)}, sparams=svec(), method=(::Type{ForwardDiff.Tag{F, V}})(), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ReverseDiff.output_hook), ReverseDiff.JacobianTape{F, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}} where F<:(ReverseDiff.var"#hessian##0#hessian##1"{var"#s179", ReverseDiff.HessianConfig{ReverseDiff.GradientConfig{ReverseDiff.TrackedArray{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}}}, ReverseDiff.JacobianConfig{ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, Nothing}}} where var"#s179"<:Function)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bf795220)[Core.MethodMatch(spec_types=Tuple{typeof(ReverseDiff.output_hook), ReverseDiff.JacobianTape{F, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}} where F<:(ReverseDiff.var"#hessian##0#hessian##1"{var"#s179", ReverseDiff.HessianConfig{ReverseDiff.GradientConfig{ReverseDiff.TrackedArray{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}}}, ReverseDiff.JacobianConfig{ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, Nothing}}} where var"#s179"<:Function)}, sparams=svec(), method=output_hook(ReverseDiff.JacobianTape{F, I, O} where O where I where F), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.ensure_indexable), Tuple{Array{Ti, 1} where Ti<:Integer}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bfd46920)[Core.MethodMatch(spec_types=Tuple{typeof(Base.ensure_indexable), Tuple{Array{Ti, 1} where Ti<:Integer}}, sparams=svec(), method=ensure_indexable(Tuple{Any, Vararg{Any}}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000046ac, 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, 0x7f94c871bae0)[ 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=0x0000000000000fa4, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Ptr{Base.DataTypeLayout}}, Ptr{Nothing}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c8358400)[Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Ptr{Base.DataTypeLayout}}, Ptr{Nothing}}, sparams=svec(Base.DataTypeLayout), method=convert(Type{Ptr{T}}, Ptr{T} where T) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c77, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.Dict{Symbol, V} where V, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb8001c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.Dict{Symbol, V} where V, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.map), Base.var"#view##0#view##1"{Base.SubArray{Float16, 1, Array{Float16, 1}, I, false}} where I<:Tuple{Array{T, 1} where T<:Integer}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bf6eb480)[Core.MethodMatch(spec_types=Tuple{typeof(Base.map), Base.var"#view##0#view##1"{Base.SubArray{Float16, 1, Array{Float16, 1}, I, false}} where I<:Tuple{Array{T, 1} where T<:Integer}, Tuple{Int64}}, sparams=svec(), method=map(Any, Tuple{Any}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006bc, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Generator{I, F} where F where I}, typeof(Base.identity), Tuple{Float16, Float16}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ccdaf420)[Core.MethodMatch(spec_types=Tuple{Type{Base.Generator{I, F} where F where I}, typeof(Base.identity), Tuple{Float16, Float16}}, sparams=svec(Tuple{Float16, Float16}, typeof(Base.identity)), method=(::Type{Base.Generator{I, F} where F where I})(F, I) where {I, F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000420, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Iterators._zip_iterate_some), Tuple{Any, Base.OneTo{Int64}}, Tuple{Tuple{}, Tuple{}}, Tuple{Any, Base.Missing}, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94cb310da0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators._zip_iterate_some), Tuple{Any, Base.OneTo{Int64}}, Tuple{Tuple{}, Tuple{}}, Tuple{Bool, Base.Missing}, 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, Base.OneTo{Int64}}, Tuple{Tuple{}, Tuple{}}, Tuple{Any, Base.Missing}, Bool}, sparams=svec(), method=_zip_iterate_some(Any, Any, Tuple{Any, Vararg{Any}}, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000018c7, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._getindex), Base.IndexLinear, Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{Bool}, Tuple{Int64}}}} where var"#s179"<:Tuple, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94cc4c9460)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._getindex), Base.IndexLinear, Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{Bool}, Tuple{Int64}}}} where var"#s179"<:Tuple, Base.IteratorsMD.CartesianIndex{N} where N}, sparams=svec(), method=_getindex(Base.IndexLinear, Any, Base.IteratorsMD.CartesianIndex{N} where N), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._getindex), Base.IndexLinear, Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{Bool}, Tuple{Int64}}}} where var"#s179"<:Tuple, Any}, sparams=svec(), method=_getindex(Base.IndexStyle, Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004880, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.extract_jacobian_chunk!), Type{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)), Any, AbstractArray{T, N} where N where T, Int64, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c523f8c0)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.extract_jacobian_chunk!), Type{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)), Any, AbstractArray{T, N} where N where T, Int64, Any}, sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c))), method=extract_jacobian_chunk!(Type{T}, Any, Any, Any, Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, 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.isinf), Tuple{Array{Float16, 1}}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bdff6c00)[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.isinf), Tuple{Array{Float16, 1}}, Nothing}, sparams=svec(typeof(Base.isinf)), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<: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, 0x7f94c3da14a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Tuple{Base.OneTo{Int64}}}, sparams=svec(), method=_axes(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047da, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:init,), Tuple{Int64}}, typeof(Base.mapfoldl), Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}, typeof(Base.add_sum), Base.Generator{Array{Int64, 1}, F} where F<:(NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{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, 0x7f94cdf31ac0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:init,), Tuple{Int64}}, typeof(Base.mapfoldl), Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}, typeof(Base.add_sum), Base.Generator{Array{Int64, 1}, F} where F<:(NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T)}, sparams=svec(), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(Base.mapfoldl), Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003201, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ReverseDiff.value), ReverseDiff.TrackedArray{V, D, N, VA, DA} where DA where VA where N where D where V}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c5451620)[ Core.MethodMatch(spec_types=Tuple{typeof(ReverseDiff.value), ReverseDiff.TrackedArray{V, D, N, VA, DA} where DA where VA where N where D where V}, sparams=svec(), method=value(ReverseDiff.TrackedArray{V, D, N, VA, DA} where DA where VA where N where D where V), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_result), Type, Type{Tuple{Main.var"#cannoles_tests##16#cannoles_tests##17"{Main.var"#F_under#cannoles_tests##7", Int64}, Array{Float64, 1}, Array{Float64, 1}}}, Any, Type{Union{}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c4eb0be0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_result), Type{T}, Type{Tuple{Main.var"#cannoles_tests##16#cannoles_tests##17"{Main.var"#F_under#cannoles_tests##7", Int64}, Array{Float64, 1}, Array{Float64, 1}}}, Type{Union{}}, Type{Union{}}} where T, sparams=svec(T, Tuple{Main.var"#cannoles_tests##16#cannoles_tests##17"{Main.var"#F_under#cannoles_tests##7", Int64}, Array{Float64, 1}, Array{Float64, 1}}), 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{Main.var"#cannoles_tests##16#cannoles_tests##17"{Main.var"#F_under#cannoles_tests##7", Int64}, Array{Float64, 1}, Array{Float64, 1}}}, Type{T}, Type{Union{}}} where T, sparams=svec(T, Union{}), method=promote_result(Type, Type, Type{T}, Type{S}) where {T, S}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000603, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._tuple_error), Type{var"#s175"} where var"#s175"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}), Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}, Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}), Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94beaee260)[Core.MethodMatch(spec_types=Tuple{typeof(Base._tuple_error), Type{var"#s175"} where var"#s175"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}), Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}, Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}), Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}}, sparams=svec(), method=_tuple_error(Type, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000372, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cbd96c40)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{}}, 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.convert), Type{var"#s179"} where var"#s179"<:Tuple{Array{Int64, 1}, Real}, Tuple{Array{Int64, 1}, Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7f94fcd272e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Tuple{Array{Int64, 1}, Real}}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, Tuple{Array{Int64, 1}, Real}} where T<:Tuple{Array{Int64, 1}, Real}, sparams=svec(T<:Tuple), method=convert(Type{T}, T) where {T<:Tuple}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{var"#s179"} where var"#s179"<:Tuple{Array{Int64, 1}, Real}, Tuple{Array{Int64, 1}, Real}}, sparams=svec(2, var"#s179"<:Tuple{Array{Int64, 1}, Real}), method=convert(Type{T}, Tuple{Vararg{Any, N}}) where {N, T<:Tuple}, fully_covers=true), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000377, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._maybe_reshape_parent), Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Tuple{Bool}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c0296220)[ Core.MethodMatch(spec_types=Tuple{typeof(Base._maybe_reshape_parent), Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Tuple{Bool}}, sparams=svec(), method=_maybe_reshape_parent(AbstractArray{var"#s16", 1} where var"#s16", Tuple{Bool}), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002dcb, 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.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Float16}}, Type{Float16}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c34bac00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(*)), Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Float16}}, Type{Float16}}, sparams=svec(Float16), method=similar(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Type{T}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047d3, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(>)), Any, Int64}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.jac_structure_residual!), Any, ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, Array{T, N} where N where T, Array{T, N} where N where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7f94cb22a8a0)[ Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_structure_residual!), ADNLPModels.SparseADJacobian{Tag, R, T, C, S} where S where C where T where R where Tag, ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, Array{T, 1} where T<:Integer, Array{T, 1} where T<:Integer}, sparams=svec(), method=jac_structure_residual!(ADNLPModels.SparseADJacobian{Tag, R, T, C, S} where S where C where T where R where Tag, ADNLPModels.AbstractADNLSModel{T, S} where S where T, AbstractArray{var"#s103", 1} where var"#s103"<:Integer, AbstractArray{var"#s102", 1} where var"#s102"<:Integer), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_structure_residual!), ADNLPModels.ADBackend, ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, Array{T, 1} where T<:Integer, Array{T, 1} where T<:Integer}, sparams=svec(), method=jac_structure_residual!(ADNLPModels.ADBackend, ADNLPModels.AbstractADNLSModel{T, S} where S where T, AbstractArray{var"#s103", 1} where var"#s103"<:Integer, AbstractArray{var"#s102", 1} where var"#s102"<:Integer), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_structure_residual!), NLPModels.AbstractNLPModel{T, S} where S where T, ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, Array{T, 1} where T<:Integer, Array{T, 1} where T<:Integer}, sparams=svec(), method=jac_structure_residual!(NLPModels.AbstractNLPModel{T, S} where S where T, ADNLPModels.AbstractADNLSModel{T, S} where S where T, AbstractArray{var"#s103", 1} where var"#s103"<:Integer, AbstractArray{var"#s102", 1} where var"#s102"<:Integer), fully_covers=false), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ad, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.check_parent_index_match), Array{Float16, 1}, Tuple{Union{Base.LogicalIndex{Int64, Array{Bool, 1}}, Array{T, 1} where T<:Integer}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bf7ca0e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.check_parent_index_match), Array{Float16, 1}, Tuple{Union{Base.LogicalIndex{Int64, Array{Bool, 1}}, Array{T, 1} where T<:Integer}}}, sparams=svec(), method=check_parent_index_match(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002d95, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.length), Array{T, 1} where T<:Union{Float32, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cd96ad80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.length), Array{T, 1} where T<:Union{Float32, Float64}}, sparams=svec(T<:Union{Float32, Float64}), method=length(Array{T, 1}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000030c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.rem), UInt64, Type{UInt64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cdf62ac0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.rem), UInt64, Type{UInt64}}, sparams=svec(UInt64), method=rem(T, Type{T}) where {T<:Integer}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000b6d, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.hess_structure!), Any, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, Array{T, N} where N where T, Array{T, N} where N where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7f94cb36b860)[ Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.hess_structure!), Union{ADNLPModels.SparseADHessian{Tag, R, T, C, H, S, GT} where GT where S where H where C where T where R where Tag, ADNLPModels.SparseReverseADHessian{Tagf, Tagψ, R, T, C, H, S, F, P} where P where F where S where H where C where T where R where Tagψ where Tagf}, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, Array{T, 1} where T<:Integer, Array{T, 1} where T<:Integer}, sparams=svec(), method=hess_structure!(Union{ADNLPModels.SparseADHessian{Tag, R, T, C, H, S, GT} where GT where S where H where C where T where R where Tag, ADNLPModels.SparseReverseADHessian{Tagf, Tagψ, R, T, C, H, S, F, P} where P where F where S where H where C where T where R where Tagψ where Tagf}, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{var"#s103", 1} where var"#s103"<:Integer, AbstractArray{var"#s102", 1} where var"#s102"<:Integer), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.hess_structure!), ADNLPModels.ADBackend, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, Array{T, 1} where T<:Integer, Array{T, 1} where T<:Integer}, sparams=svec(), method=hess_structure!(ADNLPModels.ADBackend, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{var"#s103", 1} where var"#s103"<:Integer, AbstractArray{var"#s102", 1} where var"#s102"<:Integer), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.hess_structure!), NLPModels.AbstractNLPModel{T, S} where S where T, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, Array{T, 1} where T<:Integer, Array{T, 1} where T<:Integer}, sparams=svec(), method=hess_structure!(NLPModels.AbstractNLPModel{T, S} where S where T, NLPModels.AbstractNLPModel{T, S} where S where T, AbstractArray{var"#s103", 1} where var"#s103"<:Integer, AbstractArray{var"#s102", 1} where var"#s102"<:Integer), fully_covers=false), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ad, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{StaticArraysCore.SArray{Tuple{1}, _A, N, L} where L where N} where _A, Tuple{Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94fe7f20e0)[ Core.MethodMatch(spec_types=Tuple{Type{StaticArraysCore.SArray{Tuple{1}, _A, N, L} where L where N} where _A, Tuple{Float64}}, sparams=svec(SA<:(StaticArraysCore.SArray{Tuple{1}, _A, N, L} where L where N where _A)), method=(::Type{SA})(Tuple) where {SA<:Union{StaticArrays.SHermitianCompact{N, T, L} where L where T where N, StaticArraysCore.MArray{S, T, N, L} where L where N where T where S<:Tuple, StaticArraysCore.SArray{S, T, N, L} where L where N where T where S<:Tuple, StaticArraysCore.SizedArray{S, T, N, M, TData} where TData<:AbstractArray{T, M} where M where N where T where S<:Tuple}}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009697, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._promote_typesubtract), Type{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c86e69e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._promote_typesubtract), Type{Int64}}, sparams=svec(), method=_promote_typesubtract(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000005e6, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{NLPModels.NLPModelMeta{Float16, Array{Float16, 1}}}, Int64, Array{Float16, 1}, Array{Float16, 1}, Array{Float16, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}, Int64, Int64, Int64, Int64, Array{Float16, 1}, Array{Float16, 1}, Array{Float16, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}, Int64, Any, Int64, Any, Any, Int64, Int64, Array{Int64, 1}, Array{Int64, 1}, Bool, Bool, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cc1d8ac0)[Core.MethodMatch(spec_types=Tuple{Type{NLPModels.NLPModelMeta{Float16, Array{Float16, 1}}}, Int64, Array{Float16, 1}, Array{Float16, 1}, Array{Float16, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}, Int64, Int64, Int64, Int64, Array{Float16, 1}, Array{Float16, 1}, Array{Float16, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Int64, 1}, Int64, Any, Int64, Any, Any, Int64, Int64, Array{Int64, 1}, 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=0x00000000000096aa, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), Tuple{Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c8c51840)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.BroadcastStyle, ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), Tuple{Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}}, Nothing}, sparams=svec(F<:(ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} 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=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Type{Bool}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Base.UnitRange{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94bfa6abe0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Type{Bool}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Base.UnitRange{Int64}}, sparams=svec(), method=checkbounds(Type{Bool}, AbstractArray{T, N} where N where T, Any), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000127a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.axes), Array{T, 1} where T<:(ForwardDiff.Dual{T, V, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A) where _A)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f9500822780)[Core.MethodMatch(spec_types=Tuple{typeof(Base.axes), Array{T, 1} where T<:(ForwardDiff.Dual{T, V, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A) where _A)}, sparams=svec(), method=axes(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000122a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Type{Bool}, Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Base.Slice{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c035fe60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Type{Bool}, Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Base.Slice{Base.OneTo{Int64}}}, sparams=svec(), method=checkbounds(Type{Bool}, AbstractArray{T, N} where N where T, Any), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000127a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:(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.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64}}} where Si where S where T), 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.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64}}} where Si where S where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c19e86a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, 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.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64}}} where Si where S where T}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, 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.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64}}} where Si where S where T} where T<:(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.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64}}} where Si where S where T), sparams=svec(T), method=convert(Type{T}, T) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000034c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{F} where F<:(NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T), NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94cef957e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T} where T<:(NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T), sparams=svec(T), method=convert(Type{T}, T) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000034c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.cons_lin!), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0707cc0)[Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.cons_lin!), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T}, sparams=svec(), method=cons_lin!(Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ad, 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"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(6, 0x7f94cb057d10)[ 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"#s677", var"#s676", var"#s675", var"#s674"} where var"#s674"<:Tuple{Ref{Type{T}}, Ref{Type{S}}, Vararg{Any}} where var"#s675" where var"#s676" where var"#s677", Any) where {T, S}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Int64}, sparams=svec(), method=_broadcast_getindex(Base.Broadcast.Broadcasted{var"#s677", var"#s676", var"#s675", var"#s674"} where var"#s674" where var"#s675" where var"#s676" where var"#s677", Any), fully_covers=true), #, #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004899, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eltype), Type{Tuple{Array{Float16, 1}}}}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94cccd1460)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.eltype), Type{Tuple{Array{Float16, 1}}}}, sparams=svec(Array{Float16, 1}), method=eltype(Type{var"#s179"} where var"#s179"<:Tuple{Vararg{E}}) where {E}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006a8, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.max_values), Type{Symbol}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94feb8bf00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.max_values), Type{Symbol}}, sparams=svec(), method=max_values(Type), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001543, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{DomainError}, Float64, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bfec9a40)[Core.MethodMatch(spec_types=Tuple{Type{DomainError}, Float64, String}, sparams=svec(), method=(::Type{DomainError})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000084, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.elsize), DenseArray{T, N} where N where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb65f100)[Core.MethodMatch(spec_types=Tuple{typeof(Base.elsize), DenseArray{T, N} where N where T}, sparams=svec(), method=elsize(AbstractArray{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001248, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.first), Base.AbstractUnitRange{Int64}}, limit=3), nothing, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.Iterators.Zip{Is} where Is<:Tuple{Base.OneTo{Int64}, Any, Base.OneTo{Int64}}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c8aaad20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.Iterators.Zip{Is} where Is<:Tuple{Base.OneTo{Int64}, Any, Base.OneTo{Int64}}, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N where N where V where T, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A, Int64, ForwardDiff.Partials{N, V} where V where N}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cc4540a0)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A, Int64, ForwardDiff.Partials{N, V}} where N where V where T, sparams=svec(T, V, N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any, ForwardDiff.Partials{N, V}) where {T, V, N}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:x0,), Tuple{Array{Float64, 1}}}, Any, Int64, ADNLPModels.var"#18#19", Int64, ADNLPModels.var"#22#23"}, 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{0}, typeof(Base.identity), Tuple{Float16}, Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fec6dee0)[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.identity), Tuple{Float16}, Tuple}, sparams=svec(typeof(Base.identity)), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.memoryref), Memory{T} where T<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{_A, Float16} where _A) where _A)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c2858820)[Core.MethodMatch(spec_types=Tuple{typeof(Core.memoryref), Memory{T} where T<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{_A, Float16} where _A) where _A)}, 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.Iterators._zip_iterate_all), Tuple{Base.OneTo{Int64}, Any, Base.OneTo{Int64}}, Tuple{Tuple{}, Tuple{}, Tuple{}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cc1a6c20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators._zip_iterate_all), Tuple{Base.OneTo{Int64}, Any, Base.OneTo{Int64}}, Tuple{Tuple{}, Tuple{}, Tuple{}}}, sparams=svec(), method=_zip_iterate_all(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000018c4, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.reduce_empty), Base.MappingRF{typeof(LinearAlgebra.norm), typeof(Base.min)}, Type{Float16}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c3fb7760)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.reduce_empty), Base.MappingRF{typeof(LinearAlgebra.norm), typeof(Base.min)}, Type{Float16}}, sparams=svec(Float16), method=reduce_empty(Base.MappingRF{F, T} where T where F, Type{T}) where {T}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000323f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), Any, Any, Base.RefValue{T} where T<:(ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T), Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94cc3ff2a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Base.Broadcast.BroadcastStyle, F, Base.RefValue{T} where T<:(ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T), Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{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{T} where T<:(ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T), Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}}, sparams=svec(F), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000495a, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(var"==")), Type{Array{Float16, 1}}, Type{Array{Float16, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c9068720)[Core.MethodMatch(spec_types=Tuple{typeof(Base.:(var"==")), Type{Array{Float16, 1}}, Type{Array{Float16, 1}}}, sparams=svec(), method=var"=="(Type, Type), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000bcd, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:verbose,), Tuple{Int64}}, typeof(SolverCore.solve!), CaNNOLeS.CaNNOLeSSolver{Ti, Float64, Array{Float64, 1}, CaNNOLeS.MA57Struct, _A} where _A where Ti<:Integer, ADNLPModels.ADNLSModel{Float64, Array{Float64, 1}, Array{Int64, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fd50ae60)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:verbose,), Tuple{Int64}}, typeof(SolverCore.solve!), CaNNOLeS.CaNNOLeSSolver{Ti, Float64, Array{Float64, 1}, CaNNOLeS.MA57Struct, _A} where _A where Ti<:Integer, ADNLPModels.ADNLSModel{Float64, Array{Float64, 1}, Array{Int64, 1}}}, sparams=svec(), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(SolverCore.solve!), SolverCore.AbstractOptimizationSolver, NLPModels.AbstractNLPModel{T, S} where S where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.SubArray{Tuple{Function, Function, Array{Float64, 1}, Array{Float64, 1}}, 1, Array{Tuple{Function, Function, Array{Float64, 1}, Array{Float64, 1}}, 1}, Tuple{Base.UnitRange{Int64}}, true}}, Array{Tuple{Function, Function, Array{Float64, 1}, Array{Float64, 1}}, 1}, Tuple{Base.UnitRange{Int64}}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fd62ab00)[Core.MethodMatch(spec_types=Tuple{Type{Base.SubArray{Tuple{Function, Function, Array{Float64, 1}, Array{Float64, 1}}, 1, Array{Tuple{Function, Function, Array{Float64, 1}, Array{Float64, 1}}, 1}, Tuple{Base.UnitRange{Int64}}, true}}, Array{Tuple{Function, Function, Array{Float64, 1}, Array{Float64, 1}}, 1}, Tuple{Base.UnitRange{Int64}}, Int64, Int64}, sparams=svec(Tuple{Function, Function, Array{Float64, 1}, Array{Float64, 1}}, 1, Array{Tuple{Function, Function, Array{Float64, 1}, Array{Float64, 1}}, 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=0x0000000000002d90, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.ndims), Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(>)), Tuple{Array{Float16, 1}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), Tuple{Array{Float16, 1}, Float16}}}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), Tuple{Array{Float16, 1}, Array{Float16, 1}}}}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fe509c40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.ndims), Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(>)), Tuple{Array{Float16, 1}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), Tuple{Array{Float16, 1}, Float16}}}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), Tuple{Array{Float16, 1}, Array{Float16, 1}}}}}}}, sparams=svec(1), method=ndims(Type{var"#s677"} where var"#s677"<:(Base.Broadcast.Broadcasted{var"#s676", var"#s675", F, Args} where Args<:Tuple where F where var"#s675"<:Tuple{Vararg{Any, N}} where var"#s676")) where {N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047ee, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.increment!), Any, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c0ca2920)[ Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.increment!), NLPModels.AbstractNLSModel{T, S} where S where T, Symbol}, sparams=svec(), method=increment!(NLPModels.AbstractNLSModel{T, S} where S where T, Symbol), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.increment!), NLPModels.AbstractNLPModel{T, S} where S where T, Symbol}, sparams=svec(), method=increment!(NLPModels.AbstractNLPModel{T, S} where S where T, Symbol), fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096aa, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._isdisjoint), Any, Tuple{UInt64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(6, 0x7f94ca6c8840)[ Core.MethodMatch(spec_types=Tuple{typeof(Base._isdisjoint), Tuple{}, Tuple{UInt64}}, sparams=svec(), method=_isdisjoint(Tuple{}, Tuple{UInt64}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base._isdisjoint), Tuple{UInt64}, Tuple{UInt64}}, sparams=svec(), method=_isdisjoint(Tuple{UInt64}, Tuple{UInt64}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base._isdisjoint), Tuple, Tuple{UInt64}}, sparams=svec(), method=_isdisjoint(Tuple, Tuple{UInt64}), fully_covers=false), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000131c, max_world=0xffffffffffffffff), ambig=true), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}), Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94be9d52a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}), Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}, Int64}, sparams=svec(), method=checkbounds(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Integer), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004886, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(CaNNOLeS.update_newton_hessian!), CaNNOLeS.Newton_noFHess{Ti} where Ti<:Integer, ADNLPModels.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}, Vararg{Array{Float16, 1}, 4}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c2b9c140)[Core.MethodMatch(spec_types=Tuple{typeof(CaNNOLeS.update_newton_hessian!), CaNNOLeS.Newton_noFHess{Ti} where Ti<:Integer, ADNLPModels.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}, Vararg{Array{Float16, 1}, 4}}, sparams=svec(), method=update_newton_hessian!(CaNNOLeS.HessianStruct{Ti} where Ti, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096eb, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T}, NLPModels.NLPModelMeta{T, S} where S where T, NLPModels.NLSMeta{T, S} where S where T, NLPModels.NLSCounters, 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, ADNLPModels.var"#F!#369"{Main.var"#F_Rosen#cannoles_tests##1", Int64}, ADNLPModels.var"#c!#370"{Main.var"#c_linear#cannoles_tests##10"}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c186b9e0)[Core.MethodMatch(spec_types=Tuple{Type{ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T}, NLPModels.NLPModelMeta{T, S}, NLPModels.NLSMeta{T, S}, NLPModels.NLSCounters, 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, ADNLPModels.var"#F!#369"{Main.var"#F_Rosen#cannoles_tests##1", Int64}, ADNLPModels.var"#c!#370"{Main.var"#c_linear#cannoles_tests##10"}} where S where T, sparams=svec(T, S), method=(::Type{ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T})(NLPModels.NLPModelMeta{T, S}, NLPModels.NLSMeta{T, S}, NLPModels.NLSCounters, ADNLPModels.ADModelBackend{GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS} where HBLS where JBLS where JtvBLS where JvBLS where HvBLS where GHJ where HB where JB where JtvB where JvB where HvB where GB, Any, Any) where {T, S}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ad, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Nothing, _A, _B, var"#s179"} where var"#s179"<:Tuple where _B where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94ca1bc7a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Nothing, _A, _B, var"#s179"} where var"#s179"<: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=0x0000000000004803, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LinearAlgebra.mul!), Array{Float16, 1}, SparseMatricesCOO.SparseMatrixCOO{Float16, Ti} where Ti<:Integer, Array{Float16, 1}, Bool, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c02fb240)[Core.MethodMatch(spec_types=Tuple{typeof(LinearAlgebra.mul!), Array{Float16, 1}, SparseMatricesCOO.SparseMatrixCOO{Float16, Ti} where Ti<:Integer, Array{Float16, 1}, Bool, Bool}, sparams=svec(), method=mul!(Union{DenseArray{T, 1}, DenseArray{T, 2}, Base.ReinterpretArray{T, 1, S, A, IsReshaped} where S where IsReshaped where A<:Union{Base.SubArray{T, N, A, I, true} where I<:Union{Tuple{Vararg{Real}}, Tuple{Base.AbstractUnitRange{T} where T, Vararg{Any}}} where A<:(DenseArray{T, N} where N where T) where N where T, DenseArray{T, N} where N where T}, Base.ReinterpretArray{T, 2, S, A, IsReshaped} where S where IsReshaped where A<:Union{Base.SubArray{T, N, A, I, true} where I<:Union{Tuple{Vararg{Real}}, Tuple{Base.AbstractUnitRange{T} where T, Vararg{Any}}} where A<:(DenseArray{T, N} where N where T) where N where T, DenseArray{T, N} where N where T}, Base.ReshapedArray{T, 1, A, MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64}}} where A<:Union{Base.ReinterpretArray{T, N, S, A, IsReshaped} where S where IsReshaped where A<:Union{Base.SubArray{T, N, A, I, true} where I<:Union{Tuple{Vararg{Real}}, Tuple{Base.AbstractUnitRange{T} where T, Vararg{Any}}} where A<:(DenseArray{T, N} where N where T) where N where T, DenseArray{T, N} where N where T} where N where T, Base.SubArray{T, N, A, I, true} where I<:Union{Tuple{Vararg{Real}}, Tuple{Base.AbstractUnitRange{T} where T, Vararg{Any}}} where A<:(DenseArray{T, N} where N where T) where N where T, DenseArray{T, N} where N where T}, Base.ReshapedArray{T, 2, A, MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64}}} where A<:Union{Base.ReinterpretArray{T, N, S, A, IsReshaped} where S where IsReshaped where A<:Union{Base.SubArray{T, N, A, I, true} where I<:Union{Tuple{Vararg{Real}}, Tuple{Base.AbstractUnitRange{T} where T, Vararg{Any}}} where A<:(DenseArray{T, N} where N where T) where N where T, DenseArray{T, N} where N where T} where N where T, Base.SubArray{T, N, A, I, true} where I<:Union{Tuple{Vararg{Real}}, Tuple{Base.AbstractUnitRange{T} where T, Vararg{Any}}} where A<:(DenseArray{T, N} where N where T) where N where T, DenseArray{T, N} where N where T}, Base.SubArray{T, 1, A, I, L} where L where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex{N} where N, Base.AbstractRange{var"#s178"} where var"#s178"<:Union{Int128, Int16, Int32, Int64, Int8, UInt128, UInt16, UInt32, UInt64, UInt8}, Base.ReshapedArray{T, N, A, Tuple{}} where A<:(Base.AbstractUnitRange{T} where T) where N where T, Int128, Int16, Int32, Int64, Int8, UInt128, UInt16, UInt32, UInt64, UInt8}}} where A<:Union{Base.ReinterpretArray{T, N, S, A, IsReshaped} where S where IsReshaped where A<:Union{Base.SubArray{T, N, A, I, true} where I<:Union{Tuple{Vararg{Real}}, Tuple{Base.AbstractUnitRange{T} where T, Vararg{Any}}} where A<:(DenseArray{T, N} where N where T) where N where T, DenseArray{T, N} where N where T} where N where T, Base.ReshapedArray{T, N, A, MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64}}} where A<:Union{Base.ReinterpretArray{T, N, S, A, IsReshaped} where S where IsReshaped where A<:Union{Base.SubArray{T, N, A, I, true} where I<:Union{Tuple{Vararg{Real}}, Tuple{Base.AbstractUnitRange{T} where T, Vararg{Any}}} where A<:(DenseArray{T, N} where N where T) where N where T, DenseArray{T, N} where N where T} where N where T, Base.SubArray{T, N, A, I, true} where I<:Union{Tuple{Vararg{Real}}, Tuple{Base.AbstractUnitRange{T} where T, Vararg{Any}}} where A<:(DenseArray{T, N} where N where T) where N where T, DenseArray{T, N} where N where T} where N where T, DenseArray{T, N} where N where T}, Base.SubArray{T, 2, A, I, L} where L where I<:Tuple{Vararg{Union{Base.AbstractCartesianIndex{N} where N, Base.AbstractRange{var"#s178"} where var"#s178"<:Union{Int128, Int16, Int32, Int64, Int8, UInt128, UInt16, UInt32, UInt64, UInt8}, Base.ReshapedArray{T, N, A, Tuple{}} where A<:(Base.AbstractUnitRange{T} where T) where N where T, Int128, Int16, Int32, Int64, Int8, UInt128, UInt16, UInt32, UInt64, UInt8}}} where A<:Union{Base.ReinterpretArray{T, N, S, A, IsReshaped} where S where IsReshaped where A<:Union{Base.SubArray{T, N, A, I, true} where I<:Union{Tuple{Vararg{Real}}, Tuple{Base.AbstractUnitRange{T} where T, Vararg{Any}}} where A<:(DenseArray{T, N} where N where T) where N where T, DenseArray{T, N} where N where T} where N where T, Base.ReshapedArray{T, N, A, MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64}}} where A<:Union{Base.ReinterpretArray{T, N, S, A, IsReshaped} where S where IsReshaped where A<:Union{Base.SubArray{T, N, A, I, true} where I<:Union{Tuple{Vararg{Real}}, Tuple{Base.AbstractUnitRange{T} where T, Vararg{Any}}} where A<:(DenseArray{T, N} where N where T) where N where T, DenseArray{T, N} where N where T} where N where T, Base.SubArray{T, N, A, I, true} where I<:Union{Tuple{Vararg{Real}}, Tuple{Base.AbstractUnitRange{T} where T, Vararg{Any}}} where A<:(DenseArray{T, N} where N where T) where N where T, DenseArray{T, N} where N where T} where N where T, DenseArray{T, N} where N where T}} where T, SparseMatricesCOO.AbstractSparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv, AbstractArray{T, 1} where T, Number, Number), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ea, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c93883a0)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{Int64}}, sparams=svec(), method=(::Type{BoundsError})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000005f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core._typeof_captured_variable), Tuple{Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c42a1140)[Core.MethodMatch(spec_types=Tuple{typeof(Core._typeof_captured_variable), Tuple{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{Type{BoundsError}, Array{ForwardDiff.Dual{Nothing, Float16, N}, 1} where N, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c1f51b60)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Array{ForwardDiff.Dual{Nothing, Float16, N}, 1} where N, 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.promote_typejoin), Type{Bool}, typeof(DataType)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c27ae4a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_typejoin), Type{Bool}, typeof(DataType)}, sparams=svec(), method=promote_typejoin(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000005e4, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{CaNNOLeS.MA57Struct}, CaNNOLeS.MA57Struct}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb3311a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{CaNNOLeS.MA57Struct}, CaNNOLeS.MA57Struct}, sparams=svec(CaNNOLeS.MA57Struct), method=convert(Type{T}, T) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000002aa, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(∘)), 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.ADNLSModel{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, 0x7f94cf67b820)[Core.MethodMatch(spec_types=Tuple{typeof(Base.:(∘)), 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.ADNLSModel{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=∘(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c39, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(<=)), Any, Integer}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:init,), Tuple{Int64}}, typeof(Base.count), typeof(Base.identity), Base.Generator{Array{Int64, 1}, F} where F<:(NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{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, 0x7f94cdefb980)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:init,), Tuple{Int64}}, typeof(Base.count), typeof(Base.identity), Base.Generator{Array{Int64, 1}, F} where F<:(NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T)}, sparams=svec(), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(Base.count), Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000032c3, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(+)), Dates.TimeType, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eachindex), Base.SubArray{Any, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{T, 1} where T<:Union{Float32, Float64})}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94ceaeb1a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), Base.SubArray{Any, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{T, 1} where T<:Union{Float32, Float64})}, sparams=svec(), method=eachindex(AbstractArray{T, 1} where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000124f, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_rule), Type{Tuple{Main.var"#F_Rosen#cannoles_tests##1", Array{Float64, 1}, Array{Float64, 1}}}, Type{Tuple{Main.var"#F_linear#cannoles_tests##0", Array{Float64, 1}, Array{Float64, 1}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ca89e1c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_rule), Type{Tuple{Main.var"#F_Rosen#cannoles_tests##1", Array{Float64, 1}, Array{Float64, 1}}}, Type{Tuple{Main.var"#F_linear#cannoles_tests##0", Array{Float64, 1}, Array{Float64, 1}}}}, sparams=svec(), method=promote_rule(Type, Type), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000005fc, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Type{Base.BitArray{N} where N}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c7fc1f00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Type{Base.BitArray{N} where N}, Tuple{Base.OneTo{Int64}}}, sparams=svec(Base.BitArray{N} where N), method=similar(Type{T}, Tuple{Union{Integer, Base.OneTo{T} where T<:Integer}, Vararg{Union{Integer, Base.OneTo{T} where T<:Integer}}}) where {T<:(AbstractArray{T, N} where N where T)}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000129c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Tuple{String, Type, String, Int64, String}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f9500481820)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Tuple{String, Type, String, Int64, String}}, sparams=svec(), method=iterate(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000067a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.vect), Type{Int64}, Type{Int64}, Type{Float64}, Type{Float64}, Type{Float64}, Type{Float64}, Type{Float64}, Type{Float64}, Type{Float64}, Type{Float64}, Type{Float64}, Type{Int64}, Type{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fd612b00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.vect), Type{Int64}, Type{Int64}, Type{Float64}, Type{Float64}, Type{Float64}, Type{Float64}, Type{Float64}, Type{Float64}, Type{Float64}, Type{Float64}, Type{Float64}, Type{Int64}, Type{Int64}}, sparams=svec(typeof(DataType)), method=vect(T...) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000108f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{ADNLPModels.ADModelBackend{GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS} where HBLS where JBLS where JtvBLS where JvBLS where HvBLS where GHJ where HB where JB where JtvB where JvB where HvB where GB}, Any, Any, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, Any, ADNLPModels.EmptyADbackend, Vararg{Any, 5}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c50873e0)[Core.MethodMatch(spec_types=Tuple{Type{ADNLPModels.ADModelBackend{GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS} where HBLS where JBLS where JtvBLS where JvBLS where HvBLS where GHJ where HB where JB where JtvB where JvB where HvB where GB}, Any, Any, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, Any, ADNLPModels.EmptyADbackend, Vararg{Any, 5}}, sparams=svec(GB, HvB, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, ADNLPModels.EmptyADbackend, HB, ADNLPModels.EmptyADbackend, HvBLS, JvBLS, JtvBLS, JBLS, HBLS), method=(::Type{ADNLPModels.ADModelBackend{GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS} where HBLS where JBLS where JtvBLS where JvBLS where HvBLS where GHJ where HB where JB where JtvB where JvB where HvB where GB})(GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS) where {GB, HvB, JvB, JtvB, JB, HB, GHJ, HvBLS, JvBLS, JtvBLS, JBLS, HBLS}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ad, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), Type{ForwardDiff.Dual{T, V, _A}} where _A where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A) where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A))}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb3bc5c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), Type{ForwardDiff.Dual{T, V, _A}} where _A where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A) where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A))}, sparams=svec(T<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A)), method=similar(Array{T, 1}, Type) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010b5, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), Array{Int64, 1}, Any}, limit=1), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N where N where V where T, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A, Int64, ForwardDiff.Partials{N, V} where V where N}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ffb40f60)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A, Int64, ForwardDiff.Partials{N, V}} where N where V where T, sparams=svec(T, V, N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any, ForwardDiff.Partials{N, V}) where {T, V, N}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.increment!), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, Base.Val{:neval_jac_lin}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94be8c8f20)[Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.increment!), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, Base.Val{:neval_jac_lin}}, sparams=svec(), method=increment!(NLPModels.AbstractNLSModel{T, S} where S where T, Base.Val{:neval_jac_lin}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096aa, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#promote_eltypeof##0#promote_eltypeof##1", Type{Tuple{Function, Main.var"#c_linear#cannoles_tests##10", Array{Float64, 1}, Array{Float64, 1}}}, Tuple{Main.var"#F_linear#cannoles_tests##0", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ff5eecc0)[Core.MethodMatch(spec_types=Tuple{Base.var"#promote_eltypeof##0#promote_eltypeof##1", Type{Tuple{Function, Main.var"#c_linear#cannoles_tests##10", Array{Float64, 1}, Array{Float64, 1}}}, Tuple{Main.var"#F_linear#cannoles_tests##0", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}, sparams=svec(Tuple{Function, Main.var"#c_linear#cannoles_tests##10", Array{Float64, 1}, Array{Float64, 1}}), method=var"#promote_eltypeof##0"(Type{T}, Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000133d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Printf.Spec{Base.Val{Char(0x66000000)}}}, Bool, Bool, Bool, Bool, Bool, Int64, Int64, Bool, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cd6e4580)[Core.MethodMatch(spec_types=Tuple{Type{Printf.Spec{Base.Val{Char(0x66000000)}}}, Bool, Bool, Bool, Bool, Bool, Int64, Int64, Bool, Bool}, sparams=svec(), method=(::Type{Printf.Spec{T}})(Any, Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000967e, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), Array{UInt64, 1}, Any, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94fea62520)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Array{UInt64, 1}, Any, Int64}, sparams=svec(UInt64), method=setindex!(Array{T, N} where N, Any, Int64) where {T}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001117, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.axes), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c24fe420)[Core.MethodMatch(spec_types=Tuple{typeof(Base.axes), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, 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=0x00000000000047d8, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c8f23d00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Type{Bool}, Array{Int64, 1}, Base.UnitRange{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c9e07640)[Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Type{Bool}, Array{Int64, 1}, Base.UnitRange{Int64}}, sparams=svec(), method=checkbounds(Type{Bool}, AbstractArray{T, N} where N where T, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000127a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.structural_eachindex), Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:Function), Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c07ba960)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.structural_eachindex), Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:Function), Array{Float16, 1}}, sparams=svec(), method=structural_eachindex(AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(+)), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{Bool}, Tuple{Int64}}}}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c9725960)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(+)), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{Bool}, Tuple{Int64}}}}, Tuple{Int64}}, sparams=svec(), method=(::Type{BoundsError})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000005f, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{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.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Array{Float16, 1}}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bf4905a0)[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.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Array{Float16, 1}}, Tuple{Base.OneTo{Int64}}}, sparams=svec(typeof(Base.:(/))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Generator{I, F} where F where I}, NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T, Array{Int64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cdee8520)[Core.MethodMatch(spec_types=Tuple{Type{Base.Generator{I, F} where F where I}, NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T, Array{Int64, 1}}, sparams=svec(Array{Int64, 1}, F<:(NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T)), method=(::Type{Base.Generator{I, F} where F where I})(F, I) where {I, F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000420, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ReverseDiff.seeded_reverse_pass!), Array{Float16, 2}, ReverseDiff.JacobianTape{F, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}} where F<:(ReverseDiff.var"#hessian##0#hessian##1"{var"#s179", ReverseDiff.HessianConfig{ReverseDiff.GradientConfig{ReverseDiff.TrackedArray{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}}}, ReverseDiff.JacobianConfig{ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, Nothing}}} where var"#s179"<:Function)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bf6eac60)[Core.MethodMatch(spec_types=Tuple{typeof(ReverseDiff.seeded_reverse_pass!), Array{Float16, 2}, ReverseDiff.JacobianTape{F, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}} where F<:(ReverseDiff.var"#hessian##0#hessian##1"{var"#s179", ReverseDiff.HessianConfig{ReverseDiff.GradientConfig{ReverseDiff.TrackedArray{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}}}, ReverseDiff.JacobianConfig{ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, Nothing}}} where var"#s179"<:Function)}, sparams=svec(), method=seeded_reverse_pass!(Any, ReverseDiff.AbstractTape), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a1, 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{Float16, 1}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float16, 1}, Float16}}}}, Type{Bool}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c3ff5200)[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{Float16, 1}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float16, 1}, Float16}}}}, Type{Bool}}, sparams=svec(Bool), method=similar(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Type{T}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047d3, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), Array{ForwardDiff.Dual{Tagψ, T, 1}, 1} where T where Tagψ, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), Tuple{Array{Float16, 1}}}}, limit=1), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94cb038be0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.copyto!), Array{ForwardDiff.Dual{Tagψ, T, 1}, 1} where T where Tagψ, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), Tuple{Array{Float16, 1}}}}, sparams=svec(), method=copyto!(AbstractArray{T, N} where N where T, Base.Broadcast.Broadcasted{Nothing, Axes, F, Args} where Args<:Tuple where F where Axes), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048d0, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{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{Float16, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94be4ed480)[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{Float16, 1}}}, sparams=svec(typeof(Base.:(-))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b1, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Iterators.drop), Base.OneTo{Int64}, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ceb487e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators.drop), Base.OneTo{Int64}, Integer}, sparams=svec(), method=drop(Any, Integer), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001937, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{Nothing, Float16, _A}, 1} where _A, Array{Float16, 1}, ForwardDiff.Partials{_A, Float16} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c20c32a0)[ Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{Nothing, Float16, N}, 1}, Array{Float16, 1}, ForwardDiff.Partials{N, Float16}} where N, sparams=svec(Nothing, Float16, 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, Float16, _A}, 1} where _A, Array{Float16, 1}, ForwardDiff.Partials{_A, Float16} where _A}, sparams=svec(Nothing, Float16, _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=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(>)), Tuple{Array{Float16, 1}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), Tuple{Array{Float16, 1}, Float16}}}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), Tuple{Array{Float16, 1}, Array{Float16, 1}}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c5087f40)[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.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(>)), Tuple{Array{Float16, 1}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), Tuple{Array{Float16, 1}, Float16}}}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), Tuple{Array{Float16, 1}, Array{Float16, 1}}}}}, sparams=svec(typeof(Base.:(&))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0146900)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A, Array{Float16, 1}}, sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:Function), Float16, _A), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any) where {T, V, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(CaNNOLeS.try_to_factorize), CaNNOLeS.LDLFactStruct{Float16, Ti} where Ti<:Integer, Array{T, 1} where T, Int64, Int64, Int64, Float16}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c98e21a0)[Core.MethodMatch(spec_types=Tuple{typeof(CaNNOLeS.try_to_factorize), CaNNOLeS.LDLFactStruct{Float16, Ti} where Ti<:Integer, Array{T, 1} where T, Int64, Int64, Int64, Float16}, sparams=svec(), method=try_to_factorize(CaNNOLeS.LDLFactStruct{T, Ti} where Ti<:Integer where T, AbstractArray{T, 1} where T, Integer, Integer, Integer, Real), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096eb, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.extract_derivative!), Any, Any, Array{ForwardDiff.Dual{Tagψ, T, 1}, 1} where T where Tagψ}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c0e3eda0)[ Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.extract_derivative!), Type{T}, AbstractArray{T, N} where N where T, Array{ForwardDiff.Dual{Tagψ, T, 1}, 1} where T where Tagψ} where T, sparams=svec(T), method=extract_derivative!(Type{T}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.extract_derivative!), Type{T}, DiffResults.DiffResult{O, V, D} where D<:Tuple where V where O, Array{ForwardDiff.Dual{Tagψ, T, 1}, 1} where T where Tagψ} where T, sparams=svec(T), method=extract_derivative!(Type{T}, DiffResults.DiffResult{O, V, D} where D<:Tuple where V where O, Any) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{F} where F<:(NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T), NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c17a84a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T} where T<:(NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T), sparams=svec(T), method=convert(Type{T}, T) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000034c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{T} where T<:(ForwardDiff.Dual{Tagψ, T, 1} where Tagψ where T), Float16}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(6, 0x7f94cf9566e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Float16}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{ForwardDiff.Dual{T, V, 1}}, Float16} where V where T, sparams=svec(T, V, 1), method=convert(Type{ForwardDiff.Dual{T, V, N}}, Number) where {T, V, N}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T} where T<:(ForwardDiff.Dual{Tagψ, T, 1} where Tagψ where T), Float16}, sparams=svec(T<:(ForwardDiff.Dual{Tagψ, T, 1} where Tagψ where T)), method=convert(Type{T}, Number) where {T<:Number}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.preprocess), Nothing, Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c29a69a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.preprocess), Nothing, Real}, sparams=svec(), method=preprocess(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048cb, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.typeintersect), Type{SA} where SA<:(StaticArraysCore.StaticArray{S, T, N} where N where T where S<:Tuple), Type{AbstractArray{Float64, N} where N}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fe1c51a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.typeintersect), Type{SA} where SA<:(StaticArraysCore.StaticArray{S, T, N} where N where T where S<:Tuple), Type{AbstractArray{Float64, N} where N}}, sparams=svec(), method=typeintersect(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000527, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{ft} where ft<:Real, Real}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_typejoin), Type{Int64}, Type{Array{Float16, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c86e5e40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_typejoin), Type{Int64}, Type{Array{Float16, 1}}}, sparams=svec(), method=promote_typejoin(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000005e4, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.vector_mode_jacobian), Any, StaticArraysCore.StaticArray{S, T, 1} where S<:Tuple where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c08e61e0)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.vector_mode_jacobian), Any, StaticArraysCore.StaticArray{S, T, 1} where S<:Tuple where T}, sparams=svec(F), method=vector_mode_jacobian(F, StaticArraysCore.StaticArray{S, T, N} where N where T where S<:Tuple) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009698, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{Bool}, Tuple{Int64}}}} where var"#s179"<:Tuple, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94caf8d860)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{Bool}, Tuple{Int64}}}} where var"#s179"<: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"#s179", typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{Bool}, Tuple{Int64}}}} where var"#s179"<: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=0x000000000000925f, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.elsize), Type{Array{Float16, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c05bcc80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.elsize), Type{Array{Float16, 1}}}, sparams=svec(Float16, Array{Float16, 1}), method=elsize(Type{A}) where {T, A<:(Array{T, N} where N)}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000109b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.fill!), Base.SubArray{Any, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{T, 1} where T<:Union{Float32, Float64}), Float16}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cd83b600)[Core.MethodMatch(spec_types=Tuple{typeof(Base.fill!), Base.SubArray{Any, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{T, 1} where T<:Union{Float32, Float64}), Float16}, sparams=svec(Any), method=fill!(AbstractArray{T, N} where N, Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004706, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Type{Bool}, Array{Float16, 1}, Array{Int64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94cfb1f160)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Type{Bool}, Array{Float16, 1}, 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=0x000000000000127a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Any, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A, Tuple{Vararg{ForwardDiff.Partials{N, ForwardDiff.Dual{T, V, N}}, N}} where N where V where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94cad51360)[ Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), AbstractArray{ForwardDiff.Dual{T, ForwardDiff.Dual{T, V, N}, N}, N} where N, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A, Tuple{Vararg{ForwardDiff.Partials{N, ForwardDiff.Dual{T, V, N}}, N}}} where N where T where V where T, sparams=svec(T, V<:(ForwardDiff.Dual{T, V, N} where T where V where N), 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!), AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A, Tuple{Vararg{ForwardDiff.Partials{N, ForwardDiff.Dual{T, V, N}}, N}} where N where V where T} where N where V where T, sparams=svec(T, V, N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any) where {T, V, N}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Tuple{Tuple{Int64, Int64}, Any, Tuple{Int64, Int64}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ce60c880)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Tuple{Tuple{Int64, Int64}, Any, Tuple{Int64, Int64}}, Int64}, sparams=svec(), method=getindex(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000669, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}}, Base.UnitRange{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c8aa0ea0)[Core.MethodMatch(spec_types=Tuple{Type{LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}}, Base.UnitRange{Int64}}, sparams=svec(), method=(::Type{LinearAlgebra.Transpose{T, S}})(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000007ac7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type, Array{T, 1} where T}, limit=3), nothing, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(CaNNOLeS.get_nnzh), Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.count), Base.Generator{Array{Int64, 1}, F} where F<:(NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{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, 0x7f94cf4e0420)[Core.MethodMatch(spec_types=Tuple{typeof(Base.count), Base.Generator{Array{Int64, 1}, F} where F<:(NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T)}, sparams=svec(), method=count(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000032be, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eachindex), Base.IndexLinear, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}), Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bea167e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), Base.IndexLinear, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}), Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}}, sparams=svec(), method=eachindex(Base.IndexStyle, Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047e4, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ADNLPModels.ADNLSModel!), ADNLPModels.var"#F!#369"{var"#s179", var"#s179"} where var"#s179"<:Integer where var"#s179"<:Function, Array{Float64, 1}, Integer, ADNLPModels.var"#c!#370"{var"#s179"} where var"#s179"<:Function, Array{Float64, 1}, Array{Float64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ccad09e0)[Core.MethodMatch(spec_types=Tuple{typeof(ADNLPModels.ADNLSModel!), ADNLPModels.var"#F!#369"{var"#s179", var"#s179"} where var"#s179"<:Integer where var"#s179"<:Function, Array{Float64, 1}, Integer, ADNLPModels.var"#c!#370"{var"#s179"} where var"#s179"<:Function, Array{Float64, 1}, Array{Float64, 1}}, sparams=svec(Array{Float64, 1}), method=ADNLSModel!(Any, S, Integer, Any, S, S) where {S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ad, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.cons_nln!), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c04c8660)[Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.cons_nln!), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T}, sparams=svec(), method=cons_nln!(Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ad, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unwrapva), Type{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c86e4820)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unwrapva), Type{Int64}}, sparams=svec(), method=unwrapva(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000036d, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Iterators._zip_iterate_interleave), Tuple{Tuple{Int64, Int64}, Tuple{Int64, Int64}}, Tuple{Any}, Tuple{Base.Missing, Any, Base.Missing}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cc2c4b00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators._zip_iterate_interleave), Tuple{Tuple{Int64, Int64}, Tuple{Int64, Int64}}, Tuple{Any}, Tuple{Base.Missing, Any, Base.Missing}}, sparams=svec(), method=_zip_iterate_interleave(Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000018ca, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c2bc1340)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), Int64}, sparams=svec(), method=size(Array{T, N} where N where T, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001092, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Ti} where Ti<:Integer, Int64}, limit=3), nothing, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._any_tuple), Base.var"#TupleOrBottom##0#TupleOrBottom##1", Bool, Type{Int64}, Type{var"#s179"} where var"#s179"<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c4735d00)[Core.MethodMatch(spec_types=Tuple{typeof(Base._any_tuple), Base.var"#TupleOrBottom##0#TupleOrBottom##1", Bool, Type{Int64}, Type{var"#s179"} where var"#s179"<:Real}, sparams=svec(), method=_any_tuple(Any, Any, Any, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001ad6, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{LDLFactorizations.SQDException}, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c8115f80)[Core.MethodMatch(spec_types=Tuple{Type{LDLFactorizations.SQDException}, String}, sparams=svec(), method=(::Type{LDLFactorizations.SQDException})(String), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096d3, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:Function), Array{Float16, 1}, Int64, Tuple{Vararg{ForwardDiff.Partials{N, Float16}, N}} where N, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c01e2820)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, N}, 1}, Array{Float16, 1}, Int64, Tuple{Vararg{ForwardDiff.Partials{N, Float16}, N}}, Int64} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:Function), sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:Function), Float16, N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any, Tuple{Vararg{ForwardDiff.Partials{N, V}, N}}, Any) where {T, V, N}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LinearAlgebra.mul!), Array{Float16, 1}, LinearAlgebra.Adjoint{Float16, SparseMatricesCOO.SparseMatrixCOO{Float16, Ti}} where Ti<:Integer, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c7cc4ec0)[Core.MethodMatch(spec_types=Tuple{typeof(LinearAlgebra.mul!), Array{Float16, 1}, LinearAlgebra.Adjoint{Float16, SparseMatricesCOO.SparseMatrixCOO{Float16, Ti}} where Ti<:Integer, Array{Float16, 1}}, sparams=svec(), method=mul!(Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000007ec3, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_result), Type, Type{Tuple{Main.var"#cannoles_tests##12#cannoles_tests##13"{Main.var"#F_larger#cannoles_tests##2", Int64}, Array{Float64, 1}, Array{Float64, 1}}}, Any, Type{Tuple{Main.var"#cannoles_tests##12#cannoles_tests##13"{Main.var"#F_larger#cannoles_tests##2", Int64}, Array{Float64, 1}, Array{Float64, 1}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ca756a80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_result), Type, Type{Tuple{Main.var"#cannoles_tests##12#cannoles_tests##13"{Main.var"#F_larger#cannoles_tests##2", Int64}, Array{Float64, 1}, Array{Float64, 1}}}, Type{T}, Type{Tuple{Main.var"#cannoles_tests##12#cannoles_tests##13"{Main.var"#F_larger#cannoles_tests##2", Int64}, Array{Float64, 1}, Array{Float64, 1}}}} where T, sparams=svec(T, Tuple{Main.var"#cannoles_tests##12#cannoles_tests##13"{Main.var"#F_larger#cannoles_tests##2", Int64}, Array{Float64, 1}, Array{Float64, 1}}), method=promote_result(Type, Type, Type{T}, Type{S}) where {T, S}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000602, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.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, 0x7f94cf801140)[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=0x0000000000000505, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto_axcheck!), Array{T, 1} where T<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c09853e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.copyto_axcheck!), Array{T, 1} where T<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A}, sparams=svec(), method=copyto_axcheck!(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012b7, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.resize!), Array{T, 1} where T, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c51e5120)[Core.MethodMatch(spec_types=Tuple{typeof(Base.resize!), Array{T, 1} where T, Integer}, sparams=svec(), method=resize!(Array{T, 1} where T, Integer), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001159, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), Memory{Any}, Any, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fca64da0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Memory{Any}, Any, Int64}, sparams=svec(), method=setindex!(Memory{Any}, Any, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000039c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unsafe_copyto!), Memory{ForwardDiff.Dual{Tagψ, T, 1}} where T where Tagψ, Int64, Memory{Float16}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cde13ee0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_copyto!), Memory{ForwardDiff.Dual{Tagψ, T, 1}} where T where Tagψ, Int64, Memory{Float16}, Int64, Int64}, sparams=svec(), method=unsafe_copyto!(Memory{T} where T, Any, Memory{T} where T, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001045, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{CaNNOLeS.ParamCaNNOLeS{T} where T}, Vararg{Any, 9}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cbd73420)[Core.MethodMatch(spec_types=Tuple{Type{CaNNOLeS.ParamCaNNOLeS{T} where T}, Vararg{T, 9}} where T, sparams=svec(T), method=(::Type{CaNNOLeS.ParamCaNNOLeS{T} where T})(T, T, T, T, T, T, T, T, T) where {T}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096eb, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(StaticArrays.homogenize_shape), Tuple{Union{Int64, Base.OneTo{T} where T<:Integer, StaticArrays.SOneTo{n} where n}, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bf1df140)[Core.MethodMatch(spec_types=Tuple{typeof(StaticArrays.homogenize_shape), Tuple{Union{Int64, Base.OneTo{T} where T<:Integer, StaticArrays.SOneTo{n} where n}, Int64}}, sparams=svec(), method=homogenize_shape(Tuple{Vararg{Union{Integer, Base.OneTo{T} where T<:Integer, StaticArrays.SOneTo{n} where n}}}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009697, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Any, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A, Any, Tuple{Vararg{ForwardDiff.Partials{N, ForwardDiff.Dual{T, V, N}}, N}} where N where V where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fda56020)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), AbstractArray{ForwardDiff.Dual{T, ForwardDiff.Dual{T, V, N}, N}, N} where N, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A, Any, Tuple{Vararg{ForwardDiff.Partials{N, ForwardDiff.Dual{T, V, N}}, N}}} where N where T where V where T, sparams=svec(T, V<:(ForwardDiff.Dual{T, V, N} where T where V where N), N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any, Tuple{Vararg{ForwardDiff.Partials{N, V}, N}}) where {T, V, N}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{ADNLPModels.var"##ADNLSModel!#371", Array{Float64, 1}, Array{Int64, 1}, String, Bool, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(ADNLPModels.ADNLSModel!), ADNLPModels.var"#F!#369"{var"#s179", var"#s179"} where var"#s179"<:Integer where var"#s179"<:Function, Array{Float64, 1}, Integer, ADNLPModels.var"#c!#370"{var"#s179"} where var"#s179"<:Function, Array{Float64, 1}, Array{Float64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ccad2660)[Core.MethodMatch(spec_types=Tuple{ADNLPModels.var"##ADNLSModel!#371", Array{Float64, 1}, Array{Int64, 1}, String, Bool, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, typeof(ADNLPModels.ADNLSModel!), ADNLPModels.var"#F!#369"{var"#s179", var"#s179"} where var"#s179"<:Integer where var"#s179"<:Function, Array{Float64, 1}, Integer, ADNLPModels.var"#c!#370"{var"#s179"} where var"#s179"<:Function, Array{Float64, 1}, Array{Float64, 1}}, sparams=svec(Array{Float64, 1}), method=var"#ADNLSModel!#371"(S, AbstractArray{var"#s101", 1} where var"#s101"<:Integer, 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, typeof(ADNLPModels.ADNLSModel!), Any, S, Integer, Any, S, S) where {S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ad, 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, 0x7f94fef0aba0)[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=0x0000000000000a40, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{Any, Bool}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ca94f980)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{Any, Bool}, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000688, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.ndims), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Array{Int64, 1}, Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c3dd7d60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.ndims), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Array{Int64, 1}, Real}}, sparams=svec(), method=ndims(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=0x00000000000047ed, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{ReverseDiff.GradientConfig{I} where I}, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, Type{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}}, Array{ReverseDiff.AbstractInstruction, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0c75ce0)[Core.MethodMatch(spec_types=Tuple{Type{ReverseDiff.GradientConfig{I} where I}, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, Type{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}}, Array{ReverseDiff.AbstractInstruction, 1}}, sparams=svec(ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}), method=(::Type{ReverseDiff.GradientConfig{I} where I})(AbstractArray{T, N} where N where T, Type{D}, Array{ReverseDiff.AbstractInstruction, 1}) where {D}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ReverseDiff.seed!), ReverseDiff.TrackedReal{V, D, O} where O where D<:Real where V<:Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bfa83ce0)[Core.MethodMatch(spec_types=Tuple{typeof(ReverseDiff.seed!), ReverseDiff.TrackedReal{V, D, O} where O where D<:Real where V<:Real}, sparams=svec(), method=seed!(ReverseDiff.TrackedReal{V, D, O} where O where D<:Real where V<:Real), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(>)), Any, Any}, limit=3), nothing, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:(ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c))), ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c))}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94fe32bba0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c))}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c))} where T<:(ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c))), sparams=svec(T), method=convert(Type{T}, T) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000034c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), AbstractArray{T, 1} where T, Any}, limit=1), nothing, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{var"#s179", _A, _B, var"#s179"} where var"#s179"<:Tuple where _B where _A where var"#s179"<:Base.Broadcast.BroadcastStyle}, limit=3), nothing, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.reshape), Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Any, Int64}, limit=3), nothing, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IndexStyle}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(*)), Tuple{Base.Broadcast.Extruded{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{Bool}, Tuple{Int64}}, Float16}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ca94f560)[Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(*)), Tuple{Base.Broadcast.Extruded{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{Bool}, Tuple{Int64}}, Float16}}}, sparams=svec(), method=(::Type{Base.IndexStyle})(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047e9, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LDLFactorizations.ldl_dsolve!), Integer, Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bfa4d880)[Core.MethodMatch(spec_types=Tuple{typeof(LDLFactorizations.ldl_dsolve!), Integer, Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Array{Float16, 1}}, sparams=svec(), method=ldl_dsolve!(Any, AbstractArray{T, 1} where T, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096d3, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.hess_coord!), Any, Any, Array{T, N} where N where T, Any, Real, 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, 0x7f94cc4f1b60)[ Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.hess_coord!), NLPModels.AbstractNLPModel{T, S} where S where T, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, S, AbstractArray{T, 1} where T, Real, Base.SubArray{T, 1, P, I, L} where L where I where P where T} where S<:(Array{T, N} where N where T), sparams=svec(S<:S<:(Array{T, N} where N where T)), method=hess_coord!(NLPModels.AbstractNLPModel{T, S} where S where T, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, S, AbstractArray{T, 1} where T, Real, AbstractArray{T, 1} where T) where {S}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.hess_coord!), Union{ADNLPModels.SparseADHessian{Tag, R, T, C, H, S, GT} where GT where S where H where C where T where R where Tag, ADNLPModels.SparseReverseADHessian{Tagf, Tagψ, R, T, C, H, S, F, P} where P where F where S where H where C where T where R where Tagψ where Tagf}, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, Array{T, 1} where T, AbstractArray{T, 1} where T, Real, Base.SubArray{T, 1, P, I, L} where L where I where P where T}, sparams=svec(), method=hess_coord!(Union{ADNLPModels.SparseADHessian{Tag, R, T, C, H, S, GT} where GT where S where H where C where T where R where Tag, ADNLPModels.SparseReverseADHessian{Tagf, Tagψ, R, T, C, H, S, F, P} where P where F where S where H where C where T where R where Tagψ where Tagf}, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T, Real, AbstractArray{T, 1} where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.hess_coord!), ADNLPModels.ADBackend, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, Array{T, 1} where T, AbstractArray{T, 1} where T, Real, Base.SubArray{T, 1, P, I, L} where L where I where P where T}, sparams=svec(), method=hess_coord!(ADNLPModels.ADBackend, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T, Real, AbstractArray{T, 1} where T), fully_covers=false), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ad, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(!=)), Integer, Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c7aee000)[Core.MethodMatch(spec_types=Tuple{typeof(Base.:(!=)), Integer, Integer}, sparams=svec(), method=!=(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000bd1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{T} where T<:(ForwardDiff.Dual{T, Float16, N} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where N), ForwardDiff.Dual{T, Float16, _A} where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c))}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), Base.SubArray{Any, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{T, 1} where T<:Union{Float32, Float64})}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cd8694c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), Base.SubArray{Any, 1, P, Tuple{Base.UnitRange{Int64}}, true} where P<:(Array{T, 1} where T<:Union{Float32, Float64})}, sparams=svec(), method=combine_styles(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004830, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Generator{I, F} where F where I}, Main.var"#cannoles_tests##20#cannoles_tests##21", Base.UnitRange{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c4ceec20)[Core.MethodMatch(spec_types=Tuple{Type{Base.Generator{I, F} where F where I}, Main.var"#cannoles_tests##20#cannoles_tests##21", Base.UnitRange{Int64}}, sparams=svec(Base.UnitRange{Int64}, Main.var"#cannoles_tests##20#cannoles_tests##21"), method=(::Type{Base.Generator{I, F} where F where I})(F, I) where {I, F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000420, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_result), Type, Type{Tuple{Main.var"#F_linear#cannoles_tests##0", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}, Any, Type{Tuple{Main.var"#F_linear#cannoles_tests##0", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fe47a7e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_result), Type, Type{Tuple{Main.var"#F_linear#cannoles_tests##0", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}, Type{T}, Type{Tuple{Main.var"#F_linear#cannoles_tests##0", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}} where T, sparams=svec(T, Tuple{Main.var"#F_linear#cannoles_tests##0", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}), method=promote_result(Type, Type, Type{T}, Type{S}) where {T, S}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000602, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._maybe_reindex), Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Tuple{Base.Slice{Base.OneTo{Int64}}}, Tuple{}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bf7d9200)[Core.MethodMatch(spec_types=Tuple{typeof(Base._maybe_reindex), Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Tuple{Base.Slice{Base.OneTo{Int64}}}, Tuple{}}, sparams=svec(), method=_maybe_reindex(Any, Any, Tuple{}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002de5, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.jac_structure!), Any, ADNLPModels.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7f94c11cca60)[ Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_structure!), ADNLPModels.SparseADJacobian{Tag, R, T, C, S} where S where C where T where R where Tag, ADNLPModels.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(), method=jac_structure!(ADNLPModels.SparseADJacobian{Tag, R, T, C, S} where S where C where T where R where Tag, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{var"#s103", 1} where var"#s103"<:Integer, AbstractArray{var"#s102", 1} where var"#s102"<:Integer), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_structure!), ADNLPModels.ADBackend, ADNLPModels.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(), method=jac_structure!(ADNLPModels.ADBackend, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{var"#s103", 1} where var"#s103"<:Integer, AbstractArray{var"#s102", 1} where var"#s102"<:Integer), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_structure!), NLPModels.AbstractNLPModel{T, S} where S where T, ADNLPModels.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(), method=jac_structure!(NLPModels.AbstractNLPModel{T, S} where S where T, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{var"#s103", 1} where var"#s103"<:Integer, AbstractArray{var"#s102", 1} where var"#s102"<:Integer), fully_covers=false), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ad, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.memoryref), Memory{ForwardDiff.Dual{T, Float16, _A}} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c24ff1c0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.memoryref), Memory{ForwardDiff.Dual{T, Float16, _A}} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A}, 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{Base.var"#TupleOrBottom##0#TupleOrBottom##1", Type}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c4856840)[Core.MethodMatch(spec_types=Tuple{Base.var"#TupleOrBottom##0#TupleOrBottom##1", Type}, sparams=svec(), method=var"#TupleOrBottom##0"(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000063f, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiffStaticArraysExt.extract_jacobian), Type{Nothing}, Any, StaticArraysCore.StaticArray{S, T, 1} where S<:Tuple where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94cbc76ce0)[ Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiffStaticArraysExt.extract_jacobian), Type{Nothing}, StaticArraysCore.StaticArray{S, T, N} where N where T where S<:Tuple, S} where S<:(StaticArraysCore.StaticArray{S, T, 1} where S<:Tuple where T), sparams=svec(Nothing, S<:S<:(StaticArraysCore.StaticArray{S, T, 1} where S<:Tuple where T)), method=extract_jacobian(Type{T}, StaticArraysCore.StaticArray{S, T, N} where N where T where S<:Tuple, S) where {T, S<:(StaticArraysCore.StaticArray{S, T, N} where N where T where S<:Tuple)}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiffStaticArraysExt.extract_jacobian), Type{Nothing}, AbstractArray{T, N} where N where T, StaticArraysCore.StaticArray{S, T, 1} where S<:Tuple where T}, sparams=svec(Nothing), method=extract_jacobian(Type{T}, AbstractArray{T, N} where N where T, StaticArraysCore.StaticArray{S, T, N} where N where T where S<:Tuple) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009698, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:nnzj, :nnzh, :lin), var"#s179"} where var"#s179"<:Tuple{Any, Any, Array{Int64, 1}}, Type{NLPModels.NLSMeta{Float16, Array{Float16, 1}}}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0a62a20)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:nnzj, :nnzh, :lin), var"#s179"} where var"#s179"<:Tuple{Any, Any, Array{Int64, 1}}, Type{NLPModels.NLSMeta{Float16, Array{Float16, 1}}}, Int64, Int64}, sparams=svec(Float16, Array{Float16, 1}), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, Type{NLPModels.NLSMeta{T, S}}, Int64, Int64) where {T, S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096aa, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c09bce00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A}, sparams=svec(), method=size(Array{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001093, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Type{Float16}, Float64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c9709040)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Type{Float16}, Float64}, sparams=svec(Float16), method=getindex(Type{T}, Any...) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010bd, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Array{Float16, 1}, Tuple{}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c199ffa0)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Array{Float16, 1}, Tuple{}}, 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.convert), Type{var"#s175"} where var"#s175"<:(Tuple{Vararg{ForwardDiff.Partials{_A, V}, _A}} where _A where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A)), Any}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Quadmath.Float128}, Tuple{VecElement{Float64}, VecElement{Float64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94be51d820)[Core.MethodMatch(spec_types=Tuple{Type{Quadmath.Float128}, Tuple{VecElement{Float64}, VecElement{Float64}}}, sparams=svec(), method=(::Type{Quadmath.Float128})(Tuple{VecElement{Float64}, VecElement{Float64}}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096b5, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.argtail), Tuple{Int64, Int64}, Any, Tuple{Int64, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ccb229e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.argtail), Tuple{Int64, Int64}, Any, Tuple{Int64, Int64}}, sparams=svec(), method=argtail(Any, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000035b, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Any, Any, Tuple, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c089a0a0)[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}}, Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any} where F, 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=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.jacobian), ForwardDiff.var"#hessian##0#hessian##1"{ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, ForwardDiff.HessianConfig{T, V, N, DG, DJ}} where DJ where DG where N where V where T where F where c, Array{Float16, 1}, ForwardDiff.JacobianConfig{T, Float16, _A, DJ} where DJ<:(Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A) where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)), Base.Val{false}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f950043aba0)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.jacobian), ForwardDiff.var"#hessian##0#hessian##1"{ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, ForwardDiff.HessianConfig{T, V, N, DG, DJ}} where DJ where DG where N where V where T where F where c, Array{Float16, 1}, ForwardDiff.JacobianConfig{T, Float16, _A, DJ} where DJ<:(Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A) where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)), Base.Val{false}}, sparams=svec(F<:(ForwardDiff.var"#hessian##0#hessian##1"{ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, ForwardDiff.HessianConfig{T, V, N, DG, DJ}} where DJ where DG where N where V where T where F where c), T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)), false), 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=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), Array{T, 1} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c5546e80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), Array{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=0x0000000000001093, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eachindex), Array{ForwardDiff.Dual{Nothing, Float16, N}, 1} where N, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c1aeb2e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), Array{ForwardDiff.Dual{Nothing, Float16, N}, 1} where N, Array{Float16, 1}}, sparams=svec(), method=eachindex(AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001254, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IndexStyle}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(-)), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94be3b42c0)[Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(-)), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{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=0x00000000000047e9, 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, 0x7f94c0d9c4a0)[Core.MethodMatch(spec_types=Tuple{Type{Float16}, Float64}, sparams=svec(), method=(::Type{Float16})(Float64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000df1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eachindex), Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:Function), Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c07aefc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:Function), Array{Float16, 1}}, sparams=svec(), method=eachindex(AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001254, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Type{Bool}, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c19c6100)[Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Type{Bool}, Array{Float16, 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=0x0000000000001279, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), Any, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, Nothing, typeof(Base.identity), Tuple{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94ca7a94e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.Broadcast.BitMaskedBitArray{N, M} where M where N, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, Nothing, typeof(Base.identity), Tuple{Int64}}}, sparams=svec(), method=materialize!(Base.Broadcast.BitMaskedBitArray{N, M} where M where N, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Any, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0}, Nothing, typeof(Base.identity), Tuple{Int64}}}, sparams=svec(), method=materialize!(Any, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000493d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), Base.Broadcast.DefaultArrayStyle{1}, Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(/)), var"#s179"} where var"#s179"<:Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Array{Float16, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bf481ac0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.Broadcast.DefaultArrayStyle{1}, Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(/)), var"#s179"} where var"#s179"<:Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Array{Float16, 1}}}, sparams=svec(), method=materialize!(Base.Broadcast.BroadcastStyle, Any, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048bf, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.extract_gradient_chunk!), Any, Any, Any, Int64, Any}, limit=3), nothing, #, #, 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, 0x7f94c7fc2b20)[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=0x000000000000129d, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"##sum#277", Base.Pairs{Symbol, Int64, Tuple{Symbol}, NamedTuple{(:init,), Tuple{Int64}}}, typeof(Base.sum), 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.ADNLSModel{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, 0x7f94cdf0ec80)[Core.MethodMatch(spec_types=Tuple{Base.var"##sum#277", Base.Pairs{Symbol, Int64, Tuple{Symbol}, NamedTuple{(:init,), Tuple{Int64}}}, typeof(Base.sum), 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.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T)}, sparams=svec(), method=var"#sum#277"(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.sum), Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003264, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(<=)), Int64, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), Any, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, _A, typeof(Base.identity), Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}} where _A}, limit=1), nothing, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), Type{ForwardDiff.Dual{T, V, _A}} where _A where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A) where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F))}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c2bb5de0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), Type{ForwardDiff.Dual{T, V, _A}} where _A where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A) where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F))}, sparams=svec(T<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A)), method=similar(Array{T, 1}, Type) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010b5, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(+)), Any, Base.UnitRange{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94cb78d4e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(+)), Any, Base.UnitRange{Int64}}, sparams=svec(typeof(Base.:(+))), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004959, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{var"#s175"} where var"#s175"<:(Array{ForwardDiff.Dual{T, Float16, _A}, 1} where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F))), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F))}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94ca136060)[ Core.MethodMatch(spec_types=Tuple{Type{Union{}}, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F))}, sparams=svec(), method=(::Type{Union{}})(Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{Array{ForwardDiff.Dual{T, Float16, _A}, 1}}, Array{ForwardDiff.Dual{T, Float16, _A}, 1}} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A, sparams=svec(T<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A), 1, S<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A)), method=(::Type{Array{T, N}})(AbstractArray{S, N}) where {T, N, S}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010df, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Tuple{Any}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c42797c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Tuple{Any}, Int64}, sparams=svec(), method=getindex(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000669, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A, Array{Float16, 1}, ForwardDiff.Partials{_A, Float16} where _A, ForwardDiff.Partials{_A, Float16} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c01a9840)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, N}, 1}, Array{Float16, 1}, ForwardDiff.Partials{_A, Float16} where _A, ForwardDiff.Partials{N, Float16}} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:Function), sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:Function), Float16, N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any, ForwardDiff.Partials{N, V}) where {T, V, N}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Base.Colon, Any, Any}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{var"#s175"} where var"#s175"<:(Array{ForwardDiff.Dual{Nothing, Float16, _A}, 1} where _A), Array{ForwardDiff.Dual{Nothing, Float16, _A}, 1} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94ffafe560)[ Core.MethodMatch(spec_types=Tuple{Type{Union{}}, Array{ForwardDiff.Dual{Nothing, Float16, _A}, 1} where _A}, sparams=svec(), method=(::Type{Union{}})(Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{Array{ForwardDiff.Dual{Nothing, Float16, _A}, 1}}, Array{ForwardDiff.Dual{Nothing, Float16, _A}, 1}} where _A where _A, sparams=svec(T<:(ForwardDiff.Dual{Nothing, Float16, _A} where _A), 1, S<:(ForwardDiff.Dual{Nothing, Float16, _A} where _A)), method=(::Type{Array{T, N}})(AbstractArray{S, N}) where {T, N, S}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010df, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.identity), Tuple{Array{R, 1} where R}, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c09b1200)[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}, Any}, sparams=svec(typeof(Base.identity)), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._eachindex), Base.IndexCartesian, Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c48af220)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._eachindex), Base.IndexCartesian, Tuple}, sparams=svec(), method=_eachindex(Base.IndexCartesian, Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047e6, 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{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94cb2c7ae0)[ Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}}}}, sparams=svec(), method=(::Type{Base.IndexStyle})(Type{var"#s677"} where var"#s677"<:(Base.Broadcast.Broadcasted{var"#s676", var"#s675", F, Args} where Args<:Tuple where F where var"#s675"<:Tuple{Any} where var"#s676")), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047ea, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.tagcount), Type{ForwardDiff.Tag{F, Float16}} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cbdb43c0)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.tagcount), Type{ForwardDiff.Tag{F, Float16}} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)}, sparams=svec(F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A), Float16), method=tagcount(Type{ForwardDiff.Tag{F, V}}) where {F, V}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.axes), Array{_A, 1} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c1ee6280)[Core.MethodMatch(spec_types=Tuple{typeof(Base.axes), Array{_A, 1} where _A}, sparams=svec(), method=axes(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000122a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), Array{Float16, 1}, Array{_A, 1} where _A}, limit=1), nothing, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.cat_similar), Tuple{Main.var"#F_linear#cannoles_tests##0", Array{Float64, 1}, Array{Float64, 1}}, Type{Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ca2653a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.cat_similar), Tuple{Main.var"#F_linear#cannoles_tests##0", Array{Float64, 1}, Array{Float64, 1}}, Type{Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}}, Tuple{Int64}}, sparams=svec(Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}), method=cat_similar(Any, Type{T}, Tuple) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001386, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LinearAlgebra.ldiv!), Array{Float16, 1}, LDLFactorizations.LDLFactorization{Float16, Ti, Ti, Ti} where Ti<:Integer, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c811c440)[Core.MethodMatch(spec_types=Tuple{typeof(LinearAlgebra.ldiv!), Array{Float16, 1}, LDLFactorizations.LDLFactorization{Float16, Ti, Ti, Ti} where Ti<:Integer, Array{Float16, 1}}, sparams=svec(Float16, Float16, Ti<:Integer, Ti<:Integer, Ti<:Integer), method=ldiv!(AbstractArray{T, 1}, LDLFactorizations.LDLFactorization{Tf, Ti, Tn, Tp}, AbstractArray{T, 1}) where {T<:Number, Tf<:Number, Ti<:Integer, Tn<:Integer, Tp<:Integer}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096d3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eltype), Any}, limit=4), nothing, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isbitstype), Type{ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bfd96ac0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.isbitstype), Type{ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}}, sparams=svec(), method=isbitstype(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000503, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.preprocess), Array{ForwardDiff.Dual{Tagψ, T, 1}, 1} where T where Tagψ, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cc64d5c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.preprocess), Array{ForwardDiff.Dual{Tagψ, T, 1}, 1} where T where Tagψ, Array{Float16, 1}}, sparams=svec(), method=preprocess(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048cb, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Base.Colon, Int64, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94cb7c3fa0)[ Core.MethodMatch(spec_types=Tuple{Base.Colon, Int64, Int64}, sparams=svec(Int64), method=Colon(T, T) where {T<:Real}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{Base.Colon, Int64, Real}, sparams=svec(), method=Colon(Real, Real), fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000082e, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(CaNNOLeS.check_nan_inf), AbstractArray{T, 1} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb54f140)[Core.MethodMatch(spec_types=Tuple{typeof(CaNNOLeS.check_nan_inf), AbstractArray{T, 1} where T}, sparams=svec(), method=check_nan_inf(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096eb, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), LinearAlgebra.Symmetric{Float16, SparseArrays.SparseMatrixCSC{Float16, Ti}} where Ti<:Integer, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c7fc3c20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), LinearAlgebra.Symmetric{Float16, SparseArrays.SparseMatrixCSC{Float16, Ti}} where Ti<:Integer, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Array{ForwardDiff.Dual{T, Float16, N}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where N, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c3a99d60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Array{ForwardDiff.Dual{T, Float16, N}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where N, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.view), Base.BitArray{N} where N, Base.BitArray{N} where N}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c4f2f6c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.view), Base.BitArray{N} where N, Base.BitArray{N} where N}, sparams=svec(1), method=view(AbstractArray{T, N} where N where T, Vararg{Any, M}) where {M}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002dd6, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.first), Base.OrdinalRange{var"#s677", var"#s676"} where var"#s676"<:Integer where var"#s677"<:Integer}, limit=3), nothing, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Float32}, Base.Rational{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c5424f80)[Core.MethodMatch(spec_types=Tuple{Type{Float32}, Base.Rational{Int64}}, sparams=svec(Int64, Float32), method=(::Type{T})(Base.Rational{S}) where {S, T<:AbstractFloat}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000302c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), ForwardDiff.HessianConfig{T, Float16, _A, DG, DJ} where DJ<:(Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A) where DG<:(Array{ForwardDiff.Dual{T, V, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A) where _A) where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:Function)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c07f8f80)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), ForwardDiff.HessianConfig{T, Float16, _A, DG, DJ} where DJ<:(Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A) where DG<:(Array{ForwardDiff.Dual{T, V, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A) where _A) where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:Function)}, 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{BoundsError}, SparseArrays.SparseMatrixCSC{Float16, Ti} where Ti<:Integer, Tuple{Integer, Integer}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c7d0b6e0)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, SparseArrays.SparseMatrixCSC{Float16, Ti} where Ti<:Integer, Tuple{Integer, Integer}}, 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.copyto_axcheck!), Array{T, 1} where T<:(ForwardDiff.Dual{T, V, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A) where _A), Array{ForwardDiff.Dual{T, V, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A) where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f9500841d00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.copyto_axcheck!), Array{T, 1} where T<:(ForwardDiff.Dual{T, V, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A) where _A), Array{ForwardDiff.Dual{T, V, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A) where _A}, sparams=svec(), method=copyto_axcheck!(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012b7, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.view), Any, Base.Colon}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:(Array{Ti, 1} where Ti<:Integer), Array{Int64, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94cca3e1a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Array{Int64, 1}}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:(Array{Ti, 1} where Ti<:Integer), Array{Int64, 1}}, sparams=svec(var"#s175"<:(Array{Ti, 1} where Ti<:Integer)), method=convert(Type{T}, AbstractArray{T, N} where N where T) where {T<:(Array{T, N} where N where T)}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010dd, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), Any, Array{T, 1} where T<:Integer, Any}, 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.identity), Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cf7c7f40)[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{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, 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=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.structdiff), NamedTuple{(:x, :linsolve, :verbose), var"#s179"} where var"#s179"<:Tuple{Any, Symbol, Int64}, Type{NamedTuple{(:linsolve, :method), T} where T<:Tuple}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c1744300)[Core.MethodMatch(spec_types=Tuple{typeof(Base.structdiff), NamedTuple{(:x, :linsolve, :verbose), var"#s179"} where var"#s179"<:Tuple{Any, Symbol, Int64}, Type{NamedTuple{(:linsolve, :method), T} where T<:Tuple}}, sparams=svec((:x, :linsolve, :verbose), (:linsolve, :method)), 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=0x0000000000001aba, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Base.Broadcast.Broadcasted{Nothing, Axes, F, Args} where Args<:Tuple where F where Axes}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float16, 1}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), Tuple{Array{Float16, 1}, Float16}}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c1b88780)[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{Float16, 1}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), Tuple{Array{Float16, 1}, Float16}}}}}, sparams=svec(Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float16, 1}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), Tuple{Array{Float16, 1}, Float16}}}), method=convert(Type{Base.Broadcast.Broadcasted{NewStyle, Axes, F, Args} where Args<:Tuple where F where Axes}, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where var"#s677") where {NewStyle, Axes, F, Args}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047d1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"##mapfoldl#270", Int64, typeof(Base.mapfoldl), Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}, typeof(Base.add_sum), Base.Generator{Array{Int64, 1}, F} where F<:(NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{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, 0x7f94cf4fe6e0)[Core.MethodMatch(spec_types=Tuple{Base.var"##mapfoldl#270", Int64, typeof(Base.mapfoldl), Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}, typeof(Base.add_sum), Base.Generator{Array{Int64, 1}, F} where F<:(NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T)}, sparams=svec(), method=var"#mapfoldl#270"(Any, typeof(Base.mapfoldl), Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000031ff, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiffStaticArraysExt.dualize), Type{Nothing}, StaticArraysCore.StaticArray{S, T, 1} where S<:Tuple where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c08d6e00)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiffStaticArraysExt.dualize), Type{Nothing}, StaticArraysCore.StaticArray{S, T, 1} where S<:Tuple where T}, sparams=svec(Nothing), method=dualize(Type{T}, StaticArraysCore.StaticArray{S, T, N} where N where T where S<:Tuple) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009698, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto_axcheck!), Array{T, 1} where T<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{_A, Float16} where _A) where _A), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{_A, Float16} where _A) where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c2596600)[Core.MethodMatch(spec_types=Tuple{typeof(Base.copyto_axcheck!), Array{T, 1} where T<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{_A, Float16} where _A) where _A), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{_A, Float16} where _A) where _A}, sparams=svec(), method=copyto_axcheck!(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012b7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{var"#s175"} where var"#s175"<:(Memory{T} where T<:(ForwardDiff.Dual{T, V, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A) where _A)), UndefInitializer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c3dc6da0)[ Core.MethodMatch(spec_types=Tuple{Type{Union{}}, UndefInitializer, Int64}, sparams=svec(), method=(::Type{Union{}})(Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{Memory{T}}, UndefInitializer, Int64} where T<:(ForwardDiff.Dual{T, V, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A) where _A), sparams=svec(T<:(ForwardDiff.Dual{T, V, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A) where _A), Core.AddrSpace{Core}(0x00), :not_atomic), method=(::Type{GenericMemory{kind, T, addrspace}})(UndefInitializer, Int64) where {T, addrspace, kind}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000100, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T}, NLPModels.NLPModelMeta{T, S} where S where T, NLPModels.NLSMeta{T, S} where S where T, NLPModels.NLSCounters, 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, ADNLPModels.var"#F!#369"{Main.var"#F_Rosen#cannoles_tests##1", Int64}, Array{Int64, 1}, Array{Int64, 1}, Any, ADNLPModels.var"#c!#370"{Main.var"#c_linear#cannoles_tests##10"}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c1855a20)[Core.MethodMatch(spec_types=Tuple{Type{ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T}, NLPModels.NLPModelMeta{T, S}, NLPModels.NLSMeta{T, S}, NLPModels.NLSCounters, 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, ADNLPModels.var"#F!#369"{Main.var"#F_Rosen#cannoles_tests##1", Int64}, Array{Int64, 1}, Array{Int64, 1}, Any, ADNLPModels.var"#c!#370"{Main.var"#c_linear#cannoles_tests##10"}} where S where T, sparams=svec(T, S, Si), method=(::Type{ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T})(NLPModels.NLPModelMeta{T, S}, NLPModels.NLSMeta{T, S}, NLPModels.NLSCounters, 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=0x00000000000096ad, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:show_time, :x0), Tuple{Bool, Array{Float64, 1}}}, Any, Int64, ADNLPModels.var"#57#58", Integer, ADNLPModels.var"#F!#369"{var"#s179", var"#s179"} where var"#s179"<:Integer where var"#s179"<:Function}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:context,), var"#s179"} where var"#s179"<:Tuple{IO}, typeof(Base.sprint), typeof(Base.showerror), Any, Array{Union{Ptr{Nothing}, Base.InterpreterIP}, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c53dbc60)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:context,), var"#s179"} where var"#s179"<:Tuple{IO}, typeof(Base.sprint), typeof(Base.showerror), Any, Array{Union{Ptr{Nothing}, Base.InterpreterIP}, 1}}, sparams=svec(), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(Base.sprint), Function, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003daa, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.mapreduce_empty), Base.ComposedFunction{typeof(Base.float), typeof(LinearAlgebra.norm)}, typeof(Base.:(+)), Type{Float16}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c54d35a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.mapreduce_empty), Base.ComposedFunction{typeof(Base.float), typeof(LinearAlgebra.norm)}, typeof(Base.:(+)), Type{Float16}}, sparams=svec(), method=mapreduce_empty(Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000322f, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.__cat_offset1!), Array{Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}, 1}, Tuple{Int64}, Tuple{Bool}, Tuple{Int64}, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c20f5ee0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.__cat_offset1!), Array{Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}, 1}, Tuple{Int64}, Tuple{Bool}, Tuple{Int64}, Any}, sparams=svec(), method=__cat_offset1!(Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000013b7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.unconstrained), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb7555a0)[Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.unconstrained), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T}, sparams=svec(), method=unconstrained(NLPModels.AbstractNLPModel{T, S} where S where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096aa, 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"#s179"} where var"#s179"<:Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Array{Float16, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bf516c20)[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"#s179"} where var"#s179"<:Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Array{Float16, 1}}}, sparams=svec(Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s179"<:Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Array{Float16, 1}}), method=convert(Type{Base.Broadcast.Broadcasted{NewStyle, Axes, F, Args} where Args<:Tuple where F where Axes}, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where var"#s677") where {NewStyle, Axes, F, Args}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047d1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Val{x} where x}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fe11e820)[Core.MethodMatch(spec_types=Tuple{Type{Base.Val{x} where x}, Symbol}, sparams=svec(), method=(::Type{Base.Val{x} where x})(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000003bf, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), Tuple{Array{Float16, 1}}} where var"#s179"<:Tuple, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c25fa9e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), Tuple{Array{Float16, 1}}} where var"#s179"<:Tuple, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.argtail), Array{Int64, 1}, Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c3ad7880)[Core.MethodMatch(spec_types=Tuple{typeof(Base.argtail), Array{Int64, 1}, Real}, sparams=svec(), method=argtail(Any, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000035b, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.structdiff), NamedTuple{(:x0,), var"#s179"} where var"#s179"<:Tuple{Any}, Type{NamedTuple{(:backend, :matrix_free, :show_time, :gradient_backend, :hprod_backend, :jprod_backend, :jtprod_backend, :jacobian_backend, :hessian_backend, :ghjvprod_backend, :hprod_residual_backend, :jprod_residual_backend, :jtprod_residual_backend, :jacobian_residual_backend, :hessian_residual_backend), T} where T<:Tuple}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fce81e60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.structdiff), NamedTuple{(:x0,), var"#s179"} where var"#s179"<:Tuple{Any}, Type{NamedTuple{(:backend, :matrix_free, :show_time, :gradient_backend, :hprod_backend, :jprod_backend, :jtprod_backend, :jacobian_backend, :hessian_backend, :ghjvprod_backend, :hprod_residual_backend, :jprod_residual_backend, :jtprod_residual_backend, :jacobian_residual_backend, :hessian_residual_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, :hprod_residual_backend, :jprod_residual_backend, :jtprod_residual_backend, :jacobian_residual_backend, :hessian_residual_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=0x0000000000001aba, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.ComposedFunction{O, I} where I where O}, typeof(Base.identity), Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}, Array{Int64, 1}, Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c9365e40)[Core.MethodMatch(spec_types=Tuple{Type{Base.ComposedFunction{O, I} where I where O}, typeof(Base.identity), Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}, Array{Int64, 1}, Int64}}}, sparams=svec(), method=(::Type{Base.ComposedFunction{O, I} where I where O})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c23, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.mapfoldl_impl), Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}, typeof(Base.add_sum), Int64, Base.Generator{Array{Int64, 1}, F} where F<:(NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{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, 0x7f94cdf419e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.mapfoldl_impl), Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}, typeof(Base.add_sum), Int64, Base.Generator{Array{Int64, 1}, F} where F<:(NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T)}, sparams=svec(Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}, typeof(Base.add_sum)), method=mapfoldl_impl(F, OP, Any, Any) where {F, OP}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000031d8, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(HSL.ma57_solve), HSL.Ma57{T} where T<:Union{Float32, Float64}, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(0,), mem=Memory{Any}(0, 0x7f9509e33d90)[]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000000, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core._typeof_captured_variable), ADNLPModels.var"#F!#357"{var"#s179", var"#s179"} where var"#s179"<:Integer where var"#s179"<:Function}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ff7b5300)[Core.MethodMatch(spec_types=Tuple{typeof(Core._typeof_captured_variable), ADNLPModels.var"#F!#357"{var"#s179", var"#s179"} where var"#s179"<:Integer where var"#s179"<:Function}, 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(ReverseDiff.seeded_forward_pass!), ReverseDiff.JacobianTape{F, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, _A} where _A where F<:Function, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bf166140)[Core.MethodMatch(spec_types=Tuple{typeof(ReverseDiff.seeded_forward_pass!), ReverseDiff.JacobianTape{F, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, _A} where _A where F<:Function, Array{Float16, 1}}, sparams=svec(), method=seeded_forward_pass!(ReverseDiff.AbstractTape, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a1, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.ntuple), Base.var"#__cat_offset1!##2#__cat_offset1!##3"{Tuple{Bool}, Tuple{Int64}, _A} where _A, Int64}, limit=5), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c35dee80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.ntuple), Base.var"#__cat_offset1!##2#__cat_offset1!##3"{Tuple{Bool}, Tuple{Int64}, _A} where _A, Int64}, sparams=svec(F<:(Base.var"#__cat_offset1!##2#__cat_offset1!##3"{Tuple{Bool}, Tuple{Int64}, _A} where _A)), method=ntuple(F, Int64) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000017d0, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Array{ForwardDiff.Dual{T, Float16, N}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where N, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cdc9c1e0)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Array{ForwardDiff.Dual{T, Float16, N}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where N, 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.getindex), Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c3eb1820)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Real}, sparams=svec(), method=getindex(Number), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000a55, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ReverseDiff.jacobian!), Array{_A, 1} where _A, ReverseDiff.JacobianTape{F, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, _A} where _A where F<:Function, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bf1658e0)[Core.MethodMatch(spec_types=Tuple{typeof(ReverseDiff.jacobian!), Array{_A, 1} where _A, ReverseDiff.JacobianTape{F, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, _A} where _A where F<:Function, Array{Float16, 1}}, sparams=svec(), method=jacobian!(Any, Union{ReverseDiff.CompiledTape{T} where T<:(ReverseDiff.JacobianTape{F, I, O} where O where I where F), ReverseDiff.JacobianTape{F, I, O} where O where I where F}, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:context,), Tuple{Pair{Symbol, Bool}}}, typeof(Core.invokelatest), typeof(Base.sprint), typeof(Base.show), Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c53f9ac0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:context,), Tuple{Pair{Symbol, Bool}}}, typeof(Core.invokelatest), typeof(Base.sprint), typeof(Base.show), Any}, sparams=svec(), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(Core.invokelatest), Any, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000005d8, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Tuple{Array{R, 1} where R}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c4308480)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Tuple{Array{R, 1} where R}, Int64}, sparams=svec(), method=getindex(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000669, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A, Array{Float16, 1}, Any, Tuple{Vararg{ForwardDiff.Partials{_A, Float16}, _A}} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fdebe920)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, N}, 1}, Array{Float16, 1}, Any, Tuple{Vararg{ForwardDiff.Partials{N, Float16}, N}}} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)), sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)), Float16, N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any, Tuple{Vararg{ForwardDiff.Partials{N, V}, N}}) where {T, V, N}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, 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{Array{Float64, 1}, Base.SubArray{Float64, 1, Array{Float64, 1}, Tuple{Base.UnitRange{Int64}}, true}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c3da2060)[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{Array{Float64, 1}, Base.SubArray{Float64, 1, Array{Float64, 1}, Tuple{Base.UnitRange{Int64}}, true}}}}, sparams=svec(Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(+)), Tuple{Array{Float64, 1}, Base.SubArray{Float64, 1, Array{Float64, 1}, Tuple{Base.UnitRange{Int64}}, true}}), method=convert(Type{Base.Broadcast.Broadcasted{NewStyle, Axes, F, Args} where Args<:Tuple where F where Axes}, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where var"#s677") where {NewStyle, Axes, F, Args}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047d1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Iterators.zip), Any, Base.Iterators.Take{I} where I}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0a53c20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators.zip), Any, Base.Iterators.Take{I} where I}, sparams=svec(), method=zip(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000018a5, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Type{Bool}, Array{Float16, 1}, Array{Bool, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94bf0f0820)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Type{Bool}, Array{Float16, 1}, Array{Bool, 1}}, sparams=svec(), method=checkbounds(Type{Bool}, AbstractArray{T, N} where N where T, AbstractArray{Bool, 1}), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000046a2, 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!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{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, 0x7f94cf7b5f40)[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!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{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=0x000000000000035d, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Printf.Spec{Base.Val{Char(0x65000000)}}}, Bool, Bool, Bool, Bool, Bool, Int64, Int64, Bool, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c8db2140)[Core.MethodMatch(spec_types=Tuple{Type{Printf.Spec{Base.Val{Char(0x65000000)}}}, Bool, Bool, Bool, Bool, Bool, Int64, Int64, Bool, Bool}, sparams=svec(), method=(::Type{Printf.Spec{T}})(Any, Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000967e, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.has_offset_axes), Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A))}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb6f1ae0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.has_offset_axes), Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A))}, sparams=svec(), method=has_offset_axes(Array{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001232, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.cconvert), Type{UInt64}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f9500525fe0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.cconvert), Type{UInt64}, Int64}, sparams=svec(UInt64), method=cconvert(Type{T}, Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000380, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)), Array{Float16, 1}, Int64, Tuple{Vararg{ForwardDiff.Partials{N, Float16}, N}} where N, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c51282c0)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, N}, 1}, Array{Float16, 1}, Int64, Tuple{Vararg{ForwardDiff.Partials{N, Float16}, N}}, Int64} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)), sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)), Float16, N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any, Tuple{Vararg{ForwardDiff.Partials{N, V}, N}}, Any) where {T, V, N}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{CaNNOLeS.var"##cannoles#4", Symbol, Symbol, Base.Pairs{Symbol, _A, I, A} where A<:(NamedTuple{names, T} where T<:Tuple where names) where I<:Tuple{Vararg{Symbol}} where _A, typeof(CaNNOLeS.cannoles), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cfbea920)[Core.MethodMatch(spec_types=Tuple{CaNNOLeS.var"##cannoles#4", Symbol, Symbol, Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where T<:Tuple{Vararg{Any, N}} where names where N where V, typeof(CaNNOLeS.cannoles), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T}, sparams=svec(), method=var"#cannoles#4"(Symbol, Symbol, Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where T<:Tuple{Vararg{Any, N}} where names where N where V, typeof(CaNNOLeS.cannoles), NLPModels.AbstractNLSModel{T, S} where S where T), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096eb, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##0#__cat_offset1!##1"{Tuple{Int64}, Tuple{Bool}, Tuple{Int64}, _A}} where _A, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c1f77380)[Core.MethodMatch(spec_types=Tuple{Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##0#__cat_offset1!##1"{Tuple{Int64}, Tuple{Bool}, Tuple{Int64}, _A}} where _A, Int64}, sparams=svec(), method=(::Base.var"#_ntuple##0#_ntuple##1"{f})(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000017d5, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), Base.SubArray{_A, _B, P, I, true} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.identity), Tuple{Array{Float16, 1}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94cbda2ee0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.SubArray{_A, _B, P, I, true} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.identity), Tuple{Array{Float16, 1}}}}, sparams=svec(), method=materialize!(Any, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048be, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eachindex), Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:Function)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c07d61e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:Function)}, sparams=svec(), method=eachindex(AbstractArray{T, 1} where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000124f, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.ifelse), Any, Any, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c210a220)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.ifelse), Bool, Any, Any}, sparams=svec(), method=ifelse(Bool, Any, Any), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.ifelse), SparseConnectivityTracer.AbstractTracer{P} where P<:SparseConnectivityTracer.AbstractPattern, Any, Any}, sparams=svec(), method=ifelse(SparseConnectivityTracer.AbstractTracer{P} where P<:SparseConnectivityTracer.AbstractPattern, Any, Any), fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000967d, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.jac_nln_coord!), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94be84a640)[Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_nln_coord!), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T}, sparams=svec(), method=jac_nln_coord!(Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ad, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.index_ndims), Array{Ti, 1} where Ti<:Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bfd78220)[Core.MethodMatch(spec_types=Tuple{typeof(Base.index_ndims), Array{Ti, 1} where Ti<:Integer}, sparams=svec(), method=index_ndims(Any, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000467b, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), Array{T, 1} where T<:(ForwardDiff.Dual{T, V, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A) where _A)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c089a220)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), Array{T, 1} where T<:(ForwardDiff.Dual{T, V, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A) where _A)}, sparams=svec(), method=size(Array{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001093, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkindex), Type{Bool}, Base.OneTo{Int64}, Array{Ti, 1} where Ti<:Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94bf158420)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.checkindex), Type{Bool}, Base.OneTo{Int64}, Array{Bool, 1}}, sparams=svec(), method=checkindex(Type{Bool}, Base.AbstractUnitRange{T} where T, AbstractArray{Bool, 1}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.checkindex), Type{Bool}, Base.OneTo{Int64}, Array{Ti, 1} where Ti<:Integer}, sparams=svec(), method=checkindex(Type{Bool}, Any, AbstractArray{T, N} where N where T), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000046a4, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:(Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{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}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64}} where Si where S where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94fd947fa0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64}} where Si where S where T}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64}} where Si where S where T} where T<:(Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64}} where Si where S where T), sparams=svec(T), method=convert(Type{T}, T) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000034c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Iterators.drop), Any, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7f94c0ab78e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators.drop), Base.Iterators.Drop{I} where I, Int64}, sparams=svec(), method=drop(Base.Iterators.Drop{I} where I, Integer), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators.drop), Base.Iterators.Take{I} where I, Int64}, sparams=svec(), method=drop(Base.Iterators.Take{I} where I, Integer), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators.drop), Any, Int64}, sparams=svec(), method=drop(Any, Integer), fully_covers=true), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001939, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eps), Type{Float16}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fca3ef40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.eps), Type{Float16}}, sparams=svec(), method=eps(Type{Float16}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000ef7, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), Array{T, 1} where T<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c2a7d920)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), Array{T, 1} where T<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A)}, sparams=svec(), method=size(Array{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001093, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.to_indices), FillArrays.AbstractFill{T, 1, Axes} where Axes where T, Tuple{Any}, Tuple{Array{Int64, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0587ae0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.to_indices), FillArrays.AbstractFill{T, 1, Axes} where Axes where T, Tuple{Any}, Tuple{Array{Int64, 1}}}, sparams=svec(), method=to_indices(Any, Any, Tuple{Any, Vararg}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000fdc, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{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{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cf6e8f80)[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{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}, Tuple{Base.OneTo{Int64}}}, sparams=svec(typeof(Base.:(>))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.length), AbstractArray{T, N} where N where T}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.SubArray{Float64, 1, Array{Float64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, Array{Float64, 1}, Tuple{Base.UnitRange{Int64}}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f950021f440)[Core.MethodMatch(spec_types=Tuple{Type{Base.SubArray{Float64, 1, Array{Float64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, Array{Float64, 1}, Tuple{Base.UnitRange{Int64}}, Int64, Int64}, sparams=svec(Float64, 1, Array{Float64, 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=0x0000000000002d90, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseMatrixColorings.decompress_single_color!), SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv, Any, Int64, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7f94ff0952a0)[ Core.MethodMatch(spec_types=Tuple{typeof(SparseMatrixColorings.decompress_single_color!), SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv, AbstractArray{T, 1} where T, Int64, SparseMatrixColorings.ColumnColoringResult{M, T, G, CT, GT, VT, A} where A where VT<:AbstractArray{T, 1} where GT<:(AbstractArray{var"#s43", 1} where var"#s43"<:AbstractArray{T, 1}) where CT<:AbstractArray{T, 1} where G<:SparseMatrixColorings.BipartiteGraph{T} where T<:Integer where M<:(AbstractArray{T, 2} where T)}, sparams=svec(), method=decompress_single_color!(SparseArrays.SparseMatrixCSC{Tv, Ti} where Ti<:Integer where Tv, AbstractArray{T, 1} where T, Integer, SparseMatrixColorings.ColumnColoringResult{M, T, G, CT, GT, VT, A} where A where VT<:AbstractArray{T, 1} where GT<:(AbstractArray{var"#s43", 1} where var"#s43"<:AbstractArray{T, 1}) where CT<:AbstractArray{T, 1} where G<:SparseMatrixColorings.BipartiteGraph{T} where T<:Integer where M<:(AbstractArray{T, 2} where T)), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(SparseMatrixColorings.decompress_single_color!), SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv, AbstractArray{T, 1} where T, Int64, SparseMatrixColorings.RowColoringResult{M, T, G, CT, GT, VT, A} where A where VT<:AbstractArray{T, 1} where GT<:(AbstractArray{var"#s43", 1} where var"#s43"<:AbstractArray{T, 1}) where CT<:AbstractArray{T, 1} where G<:SparseMatrixColorings.BipartiteGraph{T} where T<:Integer where M<:(AbstractArray{T, 2} where T)}, sparams=svec(), method=decompress_single_color!(AbstractArray{T, 2} where T, AbstractArray{T, 1} where T, Integer, SparseMatrixColorings.RowColoringResult{M, T, G, CT, GT, VT, A} where A where VT<:AbstractArray{T, 1} where GT<:(AbstractArray{var"#s43", 1} where var"#s43"<:AbstractArray{T, 1}) where CT<:AbstractArray{T, 1} where G<:SparseMatrixColorings.BipartiteGraph{T} where T<:Integer where M<:(AbstractArray{T, 2} where T)), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(SparseMatrixColorings.decompress_single_color!), SparseArrays.SparseMatrixCSC{Tv, Int64} where Tv, AbstractArray{T, 1} where T, Int64, SparseMatrixColorings.StarSetColoringResult{M, T, G, CT, GT, VT, A} where A where VT<:AbstractArray{T, 1} where GT<:(AbstractArray{var"#s43", 1} where var"#s43"<:AbstractArray{T, 1}) where CT<:AbstractArray{T, 1} where G<:(SparseMatrixColorings.AdjacencyGraph{T, has_diagonal} where has_diagonal) where T<:Integer where M<:(AbstractArray{T, 2} where T)}, sparams=svec(), method=decompress_single_color!(AbstractArray{T, 2} where T, AbstractArray{T, 1} where T, Integer, SparseMatrixColorings.StarSetColoringResult{M, T, G, CT, GT, VT, A} where A where VT<:AbstractArray{T, 1} where GT<:(AbstractArray{var"#s43", 1} where var"#s43"<:AbstractArray{T, 1}) where CT<:AbstractArray{T, 1} where G<:(SparseMatrixColorings.AdjacencyGraph{T, has_diagonal} where has_diagonal) where T<:Integer where M<:(AbstractArray{T, 2} where T)), fully_covers=false), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009683, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IndexStyle}, Type{Array{Tuple{Function, Function, Array{Float64, 1}, Array{Float64, 1}}, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c38e0960)[ Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Type{Array{Tuple{Function, Function, Array{Float64, 1}, Array{Float64, 1}}, 1}}}, sparams=svec(), method=(::Type{Base.IndexStyle})(Type{var"#s179"} where var"#s179"<:(Array{T, N} where N where T)), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000fa7, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.extrude), Array{_A, 1} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c43beca0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.extrude), Array{_A, 1} where _A}, sparams=svec(), method=extrude(AbstractArray{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004894, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A, Any}, limit=3), nothing, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IndexStyle}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(var"==")), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c8879260)[Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(var"==")), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}, Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{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=0x00000000000047e9, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isempty), Tuple{Vararg{Symbol}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c7c5b2a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.isempty), Tuple{}}, sparams=svec(), method=isempty(Tuple{}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.isempty), Tuple{Vararg{Symbol}}}, sparams=svec(), method=isempty(Tuple), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000726, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.widemul), Integer, Integer}, 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"#s179"} where var"#s179"<:Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Array{Float16, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94bed8a960)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.instantiate), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s179"} where var"#s179"<:Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Array{Float16, 1}}}, sparams=svec(), method=instantiate(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004803, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.maybeconstructor), Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{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, 0x7f94cf7529c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.maybeconstructor), Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{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=0x0000000000000c37, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.map!), ForwardDiff.var"#extract_value!##0#extract_value!##1"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)), Any, AbstractArray{T, N} where N where T}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{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, 0x7f94fca81380)[Core.MethodMatch(spec_types=Tuple{typeof(Base.CoreLogging.handle_message_nothrow), Base.CoreLogging.AbstractLogger, Base.CoreLogging.LogLevel, 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=0x0000000000004f80, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ReverseDiff.track), Array{Float16, 1}, Type{Float16}, Array{ReverseDiff.AbstractInstruction, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c8fd7540)[Core.MethodMatch(spec_types=Tuple{typeof(ReverseDiff.track), Array{Float16, 1}, Type{Float16}, Array{ReverseDiff.AbstractInstruction, 1}}, sparams=svec(Float16), method=track(AbstractArray{T, N} where N where T, Type{D}, Array{ReverseDiff.AbstractInstruction, 1}) where {D}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A, Array{Float16, 1}, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7f94c093e9a0)[ Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, N}, 1}, Array{Float16, 1}, ForwardDiff.Partials{N, Float16}} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:Function), sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:Function), Float16, 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{T, Float16, N}, 1}, Array{Float16, 1}, Tuple{Vararg{ForwardDiff.Partials{N, Float16}, N}}} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:Function), sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:Function), Float16, 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{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A, Array{Float16, 1}, Any}, sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:Function), Float16, _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=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eachindex), AbstractArray{T, 1} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(6, 0x7f94bd701600)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), SparseArrays.ReadOnly{T, 1, V} where V<:AbstractArray{T, 1} where T}, sparams=svec(), method=eachindex(SparseArrays.ReadOnly{T, N, V} where V<:AbstractArray{T, N} where N where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), AbstractArray{T, 1} where T}, sparams=svec(), method=eachindex(AbstractArray{T, 1} where T), fully_covers=true), #, #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009678, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.collect_to_with_first!), Array{_A, 1} where _A, Any, 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}, var"#s179", _A}} where _A where var"#s179"<:Tuple{Any}), Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fde3a620)[Core.MethodMatch(spec_types=Tuple{typeof(Base.collect_to_with_first!), Array{_A, 1} where _A, Any, 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}, var"#s179", _A}} where _A where var"#s179"<:Tuple{Any}), Int64}, sparams=svec(), method=collect_to_with_first!(AbstractArray{T, N} where N where T, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001105, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), ForwardDiff.HessianConfig{T, Float16, _A, DG, DJ} where DJ<:(Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A) where DG<:(Array{ForwardDiff.Dual{T, V, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A) where _A) where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c3dd5040)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), ForwardDiff.HessianConfig{T, Float16, _A, DG, DJ} where DJ<:(Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A) where DG<:(Array{ForwardDiff.Dual{T, V, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A) where _A) where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._array_for), Type{Any}, Base.HasShape{1}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ff5a2c60)[Core.MethodMatch(spec_types=Tuple{typeof(Base._array_for), Type{Any}, Base.HasShape{1}, Tuple{Base.OneTo{Int64}}}, sparams=svec(Any, 1), method=_array_for(Type{T}, Base.HasShape{N}, Any) where {T, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010f1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R}}, limit=1), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94caf113e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.copyto!), Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), var"#s179"} where var"#s179"<:Tuple{Array{R, 1} where R}}, sparams=svec(), method=copyto!(AbstractArray{T, N} where N where T, Base.Broadcast.Broadcasted{Nothing, Axes, F, Args} where Args<:Tuple where F where Axes), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048d0, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(StaticArrays.need_rewrap), Any, Tuple{Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94ff189ba0)[ Core.MethodMatch(spec_types=Tuple{typeof(StaticArrays.need_rewrap), Type{SA}, Tuple{Float64}} where SA<:(StaticArraysCore.StaticArray{S, T, N} where N where T where S<:Tuple), sparams=svec(SA<:(StaticArraysCore.StaticArray{S, T, N} where N where T where S<:Tuple)), method=need_rewrap(Type{SA}, Union{Tuple, StaticArraysCore.StaticArray{S, T, N} where N where T where S<:Tuple}) where {SA<:(StaticArraysCore.StaticArray{S, T, N} where N where T where S<:Tuple)}, fully_covers=false), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009697, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(*)), Any, Int64}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.TupleOrBottom), Type{Float16}, Type{Float16}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c7f7fc00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.TupleOrBottom), Type{Float16}, Type{Float16}}, sparams=svec(), method=TupleOrBottom(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000640, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), Tuple{Array{Float16, 1}, Float16}}}, typeof(Base.:(/)), Tuple{Array{Float16, 1}, Float16}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cd958c80)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), Tuple{Array{Float16, 1}, Float16}}}, typeof(Base.:(/)), Tuple{Array{Float16, 1}, Float16}, Tuple{Base.OneTo{Int64}}}, sparams=svec(Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), Tuple{Array{Float16, 1}, Float16}), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args}})(Any, Any, Any) where {Style, Axes, F, Args}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Test.Error}, Symbol, Expr, Any, Base.ExceptionStack, LineNumberNode}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c53fdb40)[Core.MethodMatch(spec_types=Tuple{Type{Test.Error}, Symbol, Expr, Any, Base.ExceptionStack, LineNumberNode}, sparams=svec(), method=(::Type{Test.Error})(Symbol, Any, Any, Any, LineNumberNode), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009674, 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{Float16, 1}, ForwardDiff.Chunk{N} where N, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c1e5f260)[Core.MethodMatch(spec_types=Tuple{Type{ForwardDiff.JacobianConfig{T, V, N, D} where D where N where V where T}, Any, Array{Float16, 1}, ForwardDiff.Chunk{N} where N, Nothing}, sparams=svec(F, Float16, N, Nothing), 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}, T) where {F, V, N, T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Base.Broadcast.var"#broadcasted##10#broadcasted##11", Base.OrdinalRange{Int64, Int64}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bfe5a6a0)[Core.MethodMatch(spec_types=Tuple{Base.Broadcast.var"#broadcasted##10#broadcasted##11", Base.OrdinalRange{Int64, Int64}, Int64}, sparams=svec(), method=var"#broadcasted##10"(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000492c, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(+)), Int64, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.steprange_last), Any, Any, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c891dfa0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.steprange_last), T, Any, Any} where T<:Dates.TimeType, sparams=svec(T<:Dates.TimeType), method=steprange_last(T, Any, Any) where {T<:Dates.TimeType}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.steprange_last), Any, Any, Any}, sparams=svec(), method=steprange_last(Any, Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000967f, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"##mapreduce#274", Base.Pairs{Symbol, Int64, Tuple{Symbol}, NamedTuple{(:init,), Tuple{Int64}}}, typeof(Base.mapreduce), Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}, typeof(Base.add_sum), Base.Generator{Array{Int64, 1}, F} where F<:(NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{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, 0x7f94cdf30780)[Core.MethodMatch(spec_types=Tuple{Base.var"##mapreduce#274", Base.Pairs{Symbol, Int64, Tuple{Symbol}, NamedTuple{(:init,), Tuple{Int64}}}, typeof(Base.mapreduce), Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}, typeof(Base.add_sum), Base.Generator{Array{Int64, 1}, F} where F<:(NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T)}, sparams=svec(), method=var"#mapreduce#274"(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.mapreduce), Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003220, 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{Nothing, var"#s179", typeof(Base.identity), Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}} where var"#s179"<:Tuple}, limit=1), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c8ba7060)[ 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{Nothing, var"#s179", typeof(Base.identity), Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}} where var"#s179"<:Tuple}, sparams=svec(), method=copyto!(AbstractArray{T, N} where N where T, Base.Broadcast.Broadcasted{Nothing, Axes, F, Args} where Args<:Tuple where F where Axes), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048d0, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(DiffResults.jacobian), DiffResults.DiffResult{O, V, D} where D<:Tuple where V where O}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cec98980)[Core.MethodMatch(spec_types=Tuple{typeof(DiffResults.jacobian), DiffResults.DiffResult{O, V, D} where D<:Tuple where V where O}, sparams=svec(), method=jacobian(DiffResults.DiffResult{O, V, D} where D<:Tuple where V where O), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009687, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{UInt64}, Ptr{Nothing}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ceae7560)[Core.MethodMatch(spec_types=Tuple{Type{UInt64}, Ptr{Nothing}}, sparams=svec(), method=(::Type{UInt64})(Ptr{T} where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000220, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), Array{Float16, 1}, Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}}, limit=1), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c0640da0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.copyto!), Array{Float16, 1}, Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}}, 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=0x00000000000012ab, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_type), Type{Ti} where Ti<:Integer, Type{Ti} where Ti<:Integer}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}), Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94beacf400)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}), Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{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.Broadcast.check_broadcast_axes), Any, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cf750f80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.check_broadcast_axes), Any, Array{Float16, 1}}, sparams=svec(), method=check_broadcast_axes(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004864, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.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}, _A}} where _A), Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c1ec2f80)[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}, _A}} 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=0x000000000000042b, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Array{Tuple{Main.var"#cannoles_tests##16#cannoles_tests##17"{Main.var"#F_under#cannoles_tests##7", Int64}, Array{Float64, 1}, Array{Float64, 1}}, 1}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cd149be0)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Array{Tuple{Main.var"#cannoles_tests##16#cannoles_tests##17"{Main.var"#F_under#cannoles_tests##7", Int64}, Array{Float64, 1}, Array{Float64, 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(Test.record), Any, Test.Error}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7f94c823c4e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Test.record), Test.ContextTestSet, Test.Error}, sparams=svec(), method=record(Test.ContextTestSet, Any), 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), 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), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009674, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IndexStyle}, Type{Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}}} where var"#s179"<:Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94cb401520)[ Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Type{Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}}} where var"#s179"<:Tuple{Any}}, sparams=svec(), method=(::Type{Base.IndexStyle})(Type{var"#s677"} where var"#s677"<:(Base.Broadcast.Broadcasted{var"#s676", var"#s675", F, Args} where Args<:Tuple where F where var"#s675"<:Tuple{Any} where var"#s676")), fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Type{Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}}} where var"#s179"<:Tuple}, sparams=svec(), method=(::Type{Base.IndexStyle})(Type{var"#s677"} where var"#s677"<:(Base.Broadcast.Broadcasted{var"#s676", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s676")), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047eb, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isbitstype), Type{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c2a2fa80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.isbitstype), Type{Int64}}, sparams=svec(), method=isbitstype(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000503, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{ForwardDiff.Dual{_A, V, _B}} where _B where V<:(ForwardDiff.Dual{T, V, N} where T where V where N) where _A, Any, ForwardDiff.Partials{N, ForwardDiff.Dual{T, V, N}} where N where T where V}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb4b4640)[Core.MethodMatch(spec_types=Tuple{Type{ForwardDiff.Dual{T, ForwardDiff.Dual{T, V, N}, N}}, ForwardDiff.Dual{T, V, N}, ForwardDiff.Partials{N, ForwardDiff.Dual{T, V, N}}} where N where V where T where T, sparams=svec(T, V<:(ForwardDiff.Dual{T, V, N} where T where V where N), 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=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A, Array{Float16, 1}, Any, Tuple{Vararg{ForwardDiff.Partials{_A, Float16}, _A}} where _A, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c4ebb340)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, N}, 1}, Array{Float16, 1}, Any, Tuple{Vararg{ForwardDiff.Partials{N, Float16}, N}}, Any} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), Float16, N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any, Tuple{Vararg{ForwardDiff.Partials{N, V}, N}}, Any) where {T, V, N}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IndexStyle}, Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A))}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c891f1a0)[ Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A))}, sparams=svec(), method=(::Type{Base.IndexStyle})(AbstractArray{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000fa4, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Array{T, 1}} where T<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A), UndefInitializer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ffc4b3e0)[Core.MethodMatch(spec_types=Tuple{Type{Array{T, 1}} where T<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A), UndefInitializer, Int64}, sparams=svec(T<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) 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{typeof(Base.axes), Array{T, 1} where T<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0985de0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.axes), Array{T, 1} where T<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A)}, sparams=svec(), method=axes(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000122a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core._typeof_captured_variable), ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f95005832a0)[Core.MethodMatch(spec_types=Tuple{typeof(Core._typeof_captured_variable), ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c}, 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}, Array{Float16, 1}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bf6b3780)[Core.MethodMatch(spec_types=Tuple{Type{Base.SubArray{T, N, P, I, L} where L where I where P where N where T}, Array{Float16, 1}, Tuple{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=0x0000000000002d91, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), AbstractArray{T, N} where N where T, Float16, Vararg{Any}}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{Type{ReverseDiff.GradientConfig{ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}}, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, Array{ReverseDiff.AbstractInstruction, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ca890c60)[Core.MethodMatch(spec_types=Tuple{Type{ReverseDiff.GradientConfig{ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}}, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, Array{ReverseDiff.AbstractInstruction, 1}}, sparams=svec(ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}), method=(::Type{ReverseDiff.GradientConfig{I}})(Any, Any) where {I}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.maybeview), Any, Base.UnitRange{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7f94cc287960)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.maybeview), AbstractString, Base.UnitRange{Int64}}, sparams=svec(), method=maybeview(AbstractString, Base.AbstractUnitRange{var"#s215"} where var"#s215"<:Integer), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.maybeview), AbstractArray{T, N} where N where T, Base.UnitRange{Int64}}, 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.UnitRange{Int64}}, sparams=svec(), method=maybeview(Any, Any...), fully_covers=true), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003768, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb28eb60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A}, sparams=svec(), method=size(Array{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001093, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Array{Float16, 1}, Tuple{Base.LogicalIndex{Int64, Array{Bool, 1}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bfddfb80)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Array{Float16, 1}, Tuple{Base.LogicalIndex{Int64, Array{Bool, 1}}}}, 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.mightalias), Base.SubArray{Float16, 1, Array{Float16, 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}(4, 0x7f94caed9b20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.mightalias), Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Array{_A, 1} where _A}, sparams=svec(), method=mightalias(AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001312, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.print_to_string), String, Type{StaticArraysCore.SArray{Tuple{1}, _A, N, L} where L where N} where _A, String, Int64, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c5455880)[Core.MethodMatch(spec_types=Tuple{typeof(Base.print_to_string), String, Type{StaticArraysCore.SArray{Tuple{1}, _A, N, L} where L where N} where _A, String, Int64, String}, sparams=svec(), method=print_to_string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003dae, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), AbstractArray{T, N} where N where T, Any, Any, Int64}, limit=3), nothing, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.map!), Type{ForwardDiff.Dual{_A, V, N} where N where V} where _A, Array{ForwardDiff.Dual{Tagf, T, 1}, 1} where T where Tagf, Array{Float16, 1}, Base.BitArray{1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c92599e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.map!), Type{ForwardDiff.Dual{_A, V, N} where N where V} where _A, Array{ForwardDiff.Dual{Tagf, T, 1}, 1} where T where Tagf, Array{Float16, 1}, Base.BitArray{1}}, sparams=svec(F<:(Type{ForwardDiff.Dual{_A, V, N} where N where V} where _A)), method=map!(F, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000014de, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unalias), Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Base.Slice{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bf834060)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unalias), Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Base.Slice{Base.OneTo{Int64}}}, sparams=svec(), method=unalias(Any, Base.AbstractRange{T} where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001308, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseArrays.nonzeros), SparseMatricesCOO.SparseMatrixCOO{Tv, Int64} where Tv}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb9f3520)[Core.MethodMatch(spec_types=Tuple{typeof(SparseArrays.nonzeros), SparseMatricesCOO.SparseMatrixCOO{Tv, Int64} where Tv}, sparams=svec(), method=nonzeros(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ea, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.adjoint), SparseMatricesCOO.SparseMatrixCOO{Float16, Ti} where Ti<:Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c0bfbd60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.adjoint), SparseMatricesCOO.SparseMatrixCOO{Float16, Ti} where Ti<:Integer}, sparams=svec(), method=adjoint(Union{AbstractArray{T, 1}, AbstractArray{T, 2}} where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000007ad8, 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.identity), var"#s179"} where var"#s179"<:Tuple{Array{T, 1} where T<:Integer}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94cb3101e0)[ 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.identity), var"#s179"} where var"#s179"<:Tuple{Array{T, 1} where T<:Integer}}, sparams=svec(), method=materialize!(Base.Broadcast.BitMaskedBitArray{N, M} where M where N, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Any, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.identity), var"#s179"} where var"#s179"<:Tuple{Array{T, 1} where T<:Integer}}, sparams=svec(), method=materialize!(Any, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000493d, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{ReverseDiff.GradientConfig{I} where I}, Array{Float16, 1}, Type{Float16}, Array{ReverseDiff.AbstractInstruction, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c8fd6900)[Core.MethodMatch(spec_types=Tuple{Type{ReverseDiff.GradientConfig{I} where I}, Array{Float16, 1}, Type{Float16}, Array{ReverseDiff.AbstractInstruction, 1}}, sparams=svec(Float16), method=(::Type{ReverseDiff.GradientConfig{I} where I})(AbstractArray{T, N} where N where T, Type{D}, Array{ReverseDiff.AbstractInstruction, 1}) where {D}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a1, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Base.Iterators.Zip{Is} where Is<:Tuple{Base.OneTo{Int64}, Any, Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c8aaa0c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Base.Iterators.Zip{Is} where Is<:Tuple{Base.OneTo{Int64}, 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=0x00000000000018c1, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.construct_seeds), Type{ForwardDiff.Partials{_A, Float16}} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c1e62ce0)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.construct_seeds), Type{ForwardDiff.Partials{_A, Float16}} where _A}, sparams=svec(_A, Float16), method=construct_seeds(Type{ForwardDiff.Partials{N, V}}) where {N, V}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, 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, 0x7f94c3c66720)[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{typeof(Base.Broadcast.result_style), Base.Broadcast.BroadcastStyle, Base.Broadcast.DefaultArrayStyle{0}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c1257a20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.result_style), Base.Broadcast.DefaultArrayStyle{0}, Base.Broadcast.DefaultArrayStyle{0}}, sparams=svec(Base.Broadcast.DefaultArrayStyle{0}), method=result_style(S, S) where {S<:Base.Broadcast.BroadcastStyle}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.result_style), Base.Broadcast.BroadcastStyle, Base.Broadcast.DefaultArrayStyle{0}}, sparams=svec(), method=result_style(Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004838, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{ForwardDiff.JacobianConfig{T, Float16, _A, Array{ForwardDiff.Dual{T, Float16, _A}, 1}}} where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:Function), Any, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:Function)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb7d5b20)[Core.MethodMatch(spec_types=Tuple{Type{ForwardDiff.JacobianConfig{T, Float16, _A, Array{ForwardDiff.Dual{T, Float16, _A}, 1}}} where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:Function), Any, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:Function)}, sparams=svec(), method=(::Type{ForwardDiff.JacobianConfig{T, V, N, D}})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Any, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A, Any, Tuple{Vararg{ForwardDiff.Partials{N, ForwardDiff.Dual{T, V, N}}, N}} where N where V where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c4b3a380)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), AbstractArray{ForwardDiff.Dual{T, ForwardDiff.Dual{T, V, N}, N}, N} where N, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A, Any, Tuple{Vararg{ForwardDiff.Partials{N, ForwardDiff.Dual{T, V, N}}, N}}} where N where T where V where T, sparams=svec(T, V<:(ForwardDiff.Dual{T, V, N} where T where V where N), N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any, Tuple{Vararg{ForwardDiff.Partials{N, V}, N}}) where {T, V, N}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isconcretetype), Type}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c3972440)[Core.MethodMatch(spec_types=Tuple{typeof(Base.isconcretetype), Type}, sparams=svec(), method=isconcretetype(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000051d, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Array{Int64, 1}, Real}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c3980440)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<: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=0x00000000000047da, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.vector_mode_gradient), ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A, ForwardDiff.GradientConfig{T, ForwardDiff.Dual{T, V, N}, N, DG} where DG where N where V where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0c98140)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.vector_mode_gradient), ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A, ForwardDiff.GradientConfig{T, ForwardDiff.Dual{T, V, N}, N, DG} where DG where N where V where T}, sparams=svec(T, F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), method=vector_mode_gradient(F, Any, ForwardDiff.GradientConfig{T, V, N, D} where D where N where V) where {T, F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), ForwardDiff.GradientConfig{T, ForwardDiff.Dual{T, V, N}, N, DG} where DG where N where V where T, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0c99be0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), ForwardDiff.GradientConfig{T, ForwardDiff.Dual{T, V, N}, N, DG} where DG where N where V where T, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IteratorSize}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bfe946c0)[Core.MethodMatch(spec_types=Tuple{Type{Base.IteratorSize}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}, sparams=svec(), method=(::Type{Base.IteratorSize})(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000445, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_typejoin_union), Type{Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cd519300)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_typejoin_union), Type{Float64}}, sparams=svec(Float64), method=promote_typejoin_union(Type{T}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000005e8, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.axes), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb3094a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.axes), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A}, sparams=svec(), method=axes(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000122a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.construct_seeds), Type{ForwardDiff.Partials{_A, V}} where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A) where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0919920)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.construct_seeds), Type{ForwardDiff.Partials{_A, V}} where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A) where _A}, sparams=svec(_A, V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A)), method=construct_seeds(Type{ForwardDiff.Partials{N, V}}) where {N, V}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.extract_jacobian_chunk!), Type{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), Any, AbstractArray{T, N} where N where T, Int64, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cc913060)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.extract_jacobian_chunk!), Type{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), Any, AbstractArray{T, N} where N where T, Int64, Any}, sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A))), method=extract_jacobian_chunk!(Type{T}, Any, Any, Any, Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.map!), ForwardDiff.var"#extract_value!##0#extract_value!##1"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function), Any, AbstractArray{T, N} where N where T}, limit=3), nothing, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Test.trigger_test_failure_break), Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c52e5440)[Core.MethodMatch(spec_types=Tuple{typeof(Test.trigger_test_failure_break), Any}, sparams=svec(), method=trigger_test_failure_break(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009674, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Array{Float16, 1}, Type{ForwardDiff.Dual{T, Float16, _A}} where _A where T<:(ForwardDiff.Tag{_A, Float16} where _A)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c2089a80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Array{Float16, 1}, Type{ForwardDiff.Dual{T, Float16, _A}} where _A where T<:(ForwardDiff.Tag{_A, Float16} where _A)}, sparams=svec(Float16), method=similar(Array{T, 1}, Type) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010b5, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._splatmap), typeof(Base.dataids), Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94cad3a6e0)[ 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=0x0000000000002dad, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Int64}, Any}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{ForwardDiff.HessianConfig{T, V, N, DG, DJ} where DJ where DG where N where V where T}, ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A, Array{Float16, 1}, ForwardDiff.Chunk{N} where N, ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cbd8a800)[Core.MethodMatch(spec_types=Tuple{Type{ForwardDiff.HessianConfig{T, V, N, DG, DJ} where DJ where DG where N where V where T}, ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A, Array{Float16, 1}, ForwardDiff.Chunk{N} where N, ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)}, sparams=svec(F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A), Float16), method=(::Type{ForwardDiff.HessianConfig{T, V, N, DG, DJ} where DJ where DG where N where V where T})(F, AbstractArray{V, N} where N, ForwardDiff.Chunk{N} where N, Any) where {F, V}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.collect_to!), Array{_A, 1} where _A, 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}, var"#s179", _A}} where _A where var"#s179"<:Tuple{Any}), Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fde3bbe0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.collect_to!), Array{_A, 1} where _A, 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}, var"#s179", _A}} where _A where var"#s179"<:Tuple{Any}), Int64, Int64}, sparams=svec(_A), method=collect_to!(AbstractArray{T, N} where N, Any, Any, Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000110a, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Array{Float16, 1}, Type{ForwardDiff.Dual{T, Float16, _A}} where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F))}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c2558be0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Array{Float16, 1}, Type{ForwardDiff.Dual{T, Float16, _A}} where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F))}, sparams=svec(Float16), method=similar(Array{T, 1}, Type) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010b5, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IteratorsMD.CartesianIndex{N} where N}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c05641c0)[Core.MethodMatch(spec_types=Tuple{Type{Base.IteratorsMD.CartesianIndex{N} where N}, Int64}, sparams=svec(), method=(::Type{Base.IteratorsMD.CartesianIndex{N} where N})(Integer...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004585, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(StaticArrays.check_parameters), Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.size), SparseArrays.SparseMatrixCSC{Float16, Ti} where Ti<:Integer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c13f8f00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.size), SparseArrays.SparseMatrixCSC{Float16, Ti} where Ti<:Integer, Int64}, sparams=svec(Float16, 2), method=size(AbstractArray{T, N}, Any) where {T, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001228, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), Base.Broadcast.DefaultArrayStyle{N} where N, Base.SubArray{_A, _B, P, I, true} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.identity), Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb950d60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), Base.Broadcast.DefaultArrayStyle{N} where N, Base.SubArray{_A, _B, P, I, true} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.identity), Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}}}, sparams=svec(), method=materialize!(Base.Broadcast.BroadcastStyle, Any, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048bf, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.axes), Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F))}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c3ce2020)[Core.MethodMatch(spec_types=Tuple{typeof(Base.axes), Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F))}, sparams=svec(), method=axes(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000122a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.map), Base.var"#view##0#view##1"{Base.SubArray{Float16, 1, Array{Float16, 1}, I, false}} where I<:Tuple{Array{T, 1} where T<:Integer}, Tuple{Base.Slice{Base.OneTo{Int64}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bf83a560)[Core.MethodMatch(spec_types=Tuple{typeof(Base.map), Base.var"#view##0#view##1"{Base.SubArray{Float16, 1, Array{Float16, 1}, I, false}} where I<:Tuple{Array{T, 1} where T<:Integer}, Tuple{Base.Slice{Base.OneTo{Int64}}}}, sparams=svec(), method=map(Any, Tuple{Any}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000006bc, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Array{Float16, 1}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0e7a3a0)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Array{Float16, 1}, 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(SolverCore.solve!), CaNNOLeS.CaNNOLeSSolver{Int64, _A, _B, CaNNOLeS.LDLFactStruct{_A, Ti}, _C} where _C where Ti<:Integer where _A where _B where _A, ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb73efe0)[Core.MethodMatch(spec_types=Tuple{typeof(SolverCore.solve!), CaNNOLeS.CaNNOLeSSolver{Int64, _A, _B, CaNNOLeS.LDLFactStruct{_A, Ti}, _C} where _C where Ti<:Integer where _A where _B where _A, ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T}, sparams=svec(), method=solve!(SolverCore.AbstractOptimizationSolver, NLPModels.AbstractNLPModel{T, S} where S where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096b2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.ndims), Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float16, 1}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), Tuple{Array{Float16, 1}, Float16}}}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c1e0dae0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.ndims), Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float16, 1}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(<)), Tuple{Array{Float16, 1}, Float16}}}}}}, sparams=svec(1), method=ndims(Type{var"#s677"} where var"#s677"<:(Base.Broadcast.Broadcasted{var"#s676", var"#s675", F, Args} where Args<:Tuple where F where var"#s675"<:Tuple{Vararg{Any, N}} where var"#s676")) where {N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047ee, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{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!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}, Array{Int64, 1}, Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cde3ee80)[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!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}, Array{Int64, 1}, Int64}}}, sparams=svec(Base.Generator{Array{Int64, 1}, NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{Float16, Array{Float16, 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=0x0000000000000420, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(<=)), Int64, Integer}, limit=3), nothing, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Tuple{Vararg{ForwardDiff.Partials{N, ForwardDiff.Dual{T, V, N}}, N}} where N where T where V, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.to_indices), Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{Integer}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(6, 0x7f94ca2ca960)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.to_indices), Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{Int64}}, sparams=svec(), method=to_indices(Any, Tuple{Vararg{Int64}}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.to_indices), Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{Integer}}, sparams=svec(), method=to_indices(Any, Tuple{Vararg{Integer}}), fully_covers=true), #, #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000fda, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:verbose,), Tuple{Int64}}, typeof(SolverCore.solve!), CaNNOLeS.CaNNOLeSSolver{Ti, Float64, Array{Float64, 1}, CaNNOLeS.MA57Struct, _A} where _A where Ti<:Integer, ADNLPModels.ADNLSModel{Float64, Array{Float64, 1}, Array{Int64, 1}}, SolverCore.GenericExecutionStats{Float64, Array{Float64, 1}, Array{Float64, 1}, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94fd918220)[ Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:verbose,), Tuple{Int64}}, typeof(SolverCore.solve!), CaNNOLeS.CaNNOLeSSolver{Ti, Float64, Array{Float64, 1}, CaNNOLeS.MA57Struct, M}, ADNLPModels.ADNLSModel{Float64, Array{Float64, 1}, Array{Int64, 1}}, SolverCore.GenericExecutionStats{Float64, Array{Float64, 1}, Array{Float64, 1}, Any}} where M<:CaNNOLeS.HessianStruct{Ti} where Ti<:Integer, sparams=svec(Ti<:Integer, Float64, Array{Float64, 1}, CaNNOLeS.MA57Struct, M<:CaNNOLeS.HessianStruct{Ti<:Integer}), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(SolverCore.solve!), CaNNOLeS.CaNNOLeSSolver{Ti, T, V, F, M}, NLPModels.AbstractNLSModel{T, V}, SolverCore.GenericExecutionStats{T, V, V, Tsp} where Tsp) where {Ti, T, V, F, M<:CaNNOLeS.HessianStruct{Ti}}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:verbose,), Tuple{Int64}}, typeof(SolverCore.solve!), CaNNOLeS.CaNNOLeSSolver{Ti, Float64, Array{Float64, 1}, CaNNOLeS.MA57Struct, _A} where _A where Ti<:Integer, ADNLPModels.ADNLSModel{Float64, Array{Float64, 1}, Array{Int64, 1}}, SolverCore.GenericExecutionStats{Float64, Array{Float64, 1}, Array{Float64, 1}, Any}}, sparams=svec(), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(SolverCore.solve!), SolverCore.AbstractOptimizationSolver, NLPModels.AbstractNLPModel{T, S} where S where T, SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096eb, 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, 0x7f94c4daad00)[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=0x00000000000048a7, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.pointer), DenseArray{T, N} where N where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7f94c913b5a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.pointer), SparseArrays.CHOLMOD.Dense{Tv}} where Tv, sparams=svec(Tv), method=pointer(SparseArrays.CHOLMOD.Dense{Tv}) where {Tv}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.pointer), Random.UnsafeView{T} where T}, sparams=svec(), method=pointer(Random.UnsafeView{T} where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.pointer), DenseArray{T, N} where N where T}, sparams=svec(T), method=pointer(AbstractArray{T, N} where N) where {T}, fully_covers=true), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009678, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.hessian), ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c, Array{Float16, 1}, ForwardDiff.HessianConfig{T, Float16, _A, DG, DJ} where DJ<:(Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A) where DG<:(Array{ForwardDiff.Dual{T, V, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A) where _A) where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c))}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f9500599e80)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.hessian), ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c, Array{Float16, 1}, ForwardDiff.HessianConfig{T, Float16, _A, DG, DJ} where DJ<:(Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A) where DG<:(Array{ForwardDiff.Dual{T, V, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A) where _A) where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c))}, sparams=svec(F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c), T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c))), method=hessian(F, AbstractArray{T, N} where N where T, ForwardDiff.HessianConfig{T, V, N, DG, DJ} where DJ where DG where N where V) where {F, T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.StepRange{Int64, Int64}}, Any, Any, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bea6bde0)[Core.MethodMatch(spec_types=Tuple{Type{Base.StepRange{Int64, Int64}}, Any, Any, Any}, sparams=svec(Int64, Int64), method=(::Type{Base.StepRange{T, S}})(Any, Any, Any) where {T, S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000087c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._getindex), Base.IndexLinear, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c4496e80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._getindex), Base.IndexLinear, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Int64}, sparams=svec(), method=_getindex(Base.IndexStyle, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000487e, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._stable_typeof), NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{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, 0x7f94cf5508a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._stable_typeof), NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T}, sparams=svec(), method=_stable_typeof(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c14, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{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.isnan), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bf6d6d60)[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.isnan), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}, Tuple{Base.OneTo{Int64}}}, sparams=svec(typeof(Base.isnan)), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.check_broadcast_axes), Tuple, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c27c08a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.check_broadcast_axes), Tuple, Array{Float16, 1}}, sparams=svec(), method=check_broadcast_axes(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004864, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{ForwardDiff.Dual{_A, V, N} where N where V} where _A, Float16, ForwardDiff.Partials{1, Bool}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94feb37120)[ Core.MethodMatch(spec_types=Tuple{Type{ForwardDiff.Dual{_A, V, N} where N where V} where _A, Float16, ForwardDiff.Partials{1, Bool}}, sparams=svec(_A, 1, Float16, 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=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{Int64, Any}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fed1ca00)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{Int64, Any}, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000688, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Printf.Spec{Base.Val{Char(0x64000000)}}}, Bool, Bool, Bool, Bool, Bool, Int64, Int64, Bool, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0acf780)[Core.MethodMatch(spec_types=Tuple{Type{Printf.Spec{Base.Val{Char(0x64000000)}}}, Bool, Bool, Bool, Bool, Bool, Int64, Int64, Bool, Bool}, sparams=svec(), method=(::Type{Printf.Spec{T}})(Any, Any, Any, Any, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000967e, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.jac_nln_coord!), NLPModels.AbstractNLPModel{T, S} where S where T, Array{Float16, 1}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c8ba5e60)[ Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_nln_coord!), Main.MGH01CON{T, S} where S where T, Array{Float16, 1}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(), method=jac_nln_coord!(Main.MGH01CON{T, S} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_nln_coord!), Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, Array{Float16, 1}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(), method=jac_nln_coord!(Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T), fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009715, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), Any, ForwardDiff.var"#partials_wrap#extract_jacobian_chunk!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function), Any, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.sizeof), Any}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.SimdLoop.simd_inner_length), Any, Any}, limit=3), nothing, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{var"#s175"} where var"#s175"<:(Base.Dict{Symbol, _D} where _D), Base.Dict{Symbol, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7f94ccb320a0)[ Core.MethodMatch(spec_types=Tuple{Type{Union{}}, Base.Dict{Symbol, Any}}, sparams=svec(), method=(::Type{Union{}})(Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{Base.Dict{Symbol, Any}}, Base.Dict{Symbol, Any}}, sparams=svec(Symbol, Any), method=(::Type{Base.Dict{K, V}})(Base.Dict{K, V}) where {K, V}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{Base.Dict{Symbol, V}}, Base.Dict{Symbol, Any}} where V, sparams=svec(Symbol, V), method=(::Type{Base.Dict{K, V}})(Any) where {K, V}, fully_covers=false), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000034b1, 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}, ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F, Array{Float16, 1}, ForwardDiff.Chunk{N} where N, ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c2566640)[Core.MethodMatch(spec_types=Tuple{Type{ForwardDiff.JacobianConfig{T, V, N, D} where D where N where V where T}, ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F, Array{Float16, 1}, ForwardDiff.Chunk{N} where N, ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)}, sparams=svec(F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F), Float16, N, T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F))), 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}, T) where {F, V, N, T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, 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{Float16, 1}, Array{Float16, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ca1ce5a0)[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{Float16, 1}, Array{Float16, 1}}}, sparams=svec(typeof(Base.:(+))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.print), Base.GenericIOBuffer{Memory{UInt8}}, Any}, limit=3), nothing, #, #, #, #, 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{Float16, 1}, Tuple{Array{T, 1} where T<:Integer}, Tuple{Bool}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bfd47220)[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{Float16, 1}, Tuple{Array{T, 1} where T<:Integer}, Tuple{Bool}}, sparams=svec(Array{Float16, 1}, I<:Tuple{Array{T, 1} where T<:Integer}, 1), method=(::Type{Base.SubArray{T, N, P, I, L} where L where I where P where N where T})(Base.IndexCartesian, P, I, Tuple{Vararg{Any, N}}) where {P, I, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002d92, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A, Array{Float16, 1}, Any, ForwardDiff.Partials{_A, Float16} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fe0c3b40)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, N}, 1}, Array{Float16, 1}, Any, ForwardDiff.Partials{N, Float16}} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)), sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)), Float16, N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any, ForwardDiff.Partials{N, V}) where {T, V, N}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), ADNLPModels.var"#F!#369"{var"#s179", var"#s179"} where var"#s179"<:Integer where var"#s179"<:Function}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cc1a69e0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), ADNLPModels.var"#F!#369"{var"#s179", var"#s179"} where var"#s179"<:Integer where var"#s179"<:Function}, 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.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{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c876a5e0)[ 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{Float16, 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=0x0000000000001312, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Tuple{Array{Ti, 1} where Ti<:Integer}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c1095c80)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Tuple{Array{Ti, 1} where Ti<:Integer}, Int64}, sparams=svec(), method=getindex(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000669, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_result), Type{Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}}, Type{Tuple{Main.var"#cannoles_tests##12#cannoles_tests##13"{Main.var"#F_larger#cannoles_tests##2", Int64}, Array{Float64, 1}, Array{Float64, 1}}}, Type{Union{}}, Type{Union{}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ca7e2ac0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_result), Type{Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}}, Type{Tuple{Main.var"#cannoles_tests##12#cannoles_tests##13"{Main.var"#F_larger#cannoles_tests##2", Int64}, Array{Float64, 1}, Array{Float64, 1}}}, Type{Union{}}, Type{Union{}}}, sparams=svec(Tuple{Function, Array{Float64, 1}, Array{Float64, 1}}, Tuple{Main.var"#cannoles_tests##12#cannoles_tests##13"{Main.var"#F_larger#cannoles_tests##2", Int64}, Array{Float64, 1}, Array{Float64, 1}}), method=promote_result(Type{T}, Type{S}, Type{Union{}}, Type{Union{}}) where {T, S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000603, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(var"==")), Tuple{Array{Float16, 1}, Array{Float16, 1}}}, Type{Bool}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c7fa8220)[Core.MethodMatch(spec_types=Tuple{typeof(Base.similar), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Tuple{Base.OneTo{Int64}}, typeof(Base.:(var"==")), Tuple{Array{Float16, 1}, Array{Float16, 1}}}, Type{Bool}}, sparams=svec(Bool), method=similar(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Type{T}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047d3, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv}, Int64, Int64, Array{Int64, 1}, Array{Int64, 1}, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c2a17480)[Core.MethodMatch(spec_types=Tuple{Type{SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv}, Int64, Int64, Array{Int64, 1}, Array{Int64, 1}, Array{Float16, 1}}, sparams=svec(), method=(::Type{SparseMatricesCOO.SparseMatrixCOO{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=0x00000000000096ea, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Tuple{Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{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)}}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cf7c6520)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Tuple{Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{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)}}}, Int64}, sparams=svec(), method=getindex(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000669, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.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"==")), Tuple{Array{Float16, 1}, Array{Float16, 1}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c805eb60)[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"==")), Tuple{Array{Float16, 1}, Array{Float16, 1}}}}, sparams=svec(Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(var"==")), Tuple{Array{Float16, 1}, Array{Float16, 1}}), method=convert(Type{Base.Broadcast.Broadcasted{NewStyle, Axes, F, Args} where Args<:Tuple where F where Axes}, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where var"#s677") where {NewStyle, Axes, F, Args}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047d1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.MappingRF{F, T} where T where F}, Base.ComposedFunction{typeof(Base.float), typeof(LinearAlgebra.norm)}, typeof(Base.:(+))}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c559fd40)[Core.MethodMatch(spec_types=Tuple{Type{Base.MappingRF{F, T} where T where F}, Base.ComposedFunction{typeof(Base.float), typeof(LinearAlgebra.norm)}, typeof(Base.:(+))}, sparams=svec(Base.ComposedFunction{typeof(Base.float), typeof(LinearAlgebra.norm)}, typeof(Base.:(+))), method=(::Type{Base.MappingRF{F, T} where T where F})(F, T) where {F, T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000031e9, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.mightalias), Base.SubArray{_A, _B, P, I, true} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb6742a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.mightalias), Base.SubArray{_A, _B, P, I, true} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(), method=mightalias(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), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000046f6, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._getindex), Base.IndexLinear, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}), Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94be9d4780)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._getindex), Base.IndexLinear, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}), Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}, Int64}, sparams=svec(), method=_getindex(Base.IndexStyle, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000487e, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:obj_weight,), var"#s179"} where var"#s179"<:Tuple{Real}, typeof(NLPModels.hess_coord!), NLPModels.AbstractNLPModel{T, S} where S where T, Array{T, N} where N where T, Any, Base.SubArray{T, N, P, I, L} where L where I where P where N where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94cc30ba20)[ Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:obj_weight,), var"#s179"} where var"#s179"<:Tuple{Real}, typeof(NLPModels.hess_coord!), Main.MGH01CON{T, S} where S where T, Array{T, 1}, AbstractArray{T, 1} where T, Base.SubArray{T, 1, P, I, L} where L where I where P where T} where T, sparams=svec(T), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(NLPModels.hess_coord!), Main.MGH01CON{T, S} where S where T, AbstractArray{T, 1}, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:obj_weight,), var"#s179"} where var"#s179"<:Tuple{Real}, typeof(NLPModels.hess_coord!), Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, Array{T, 1} where T, AbstractArray{T, 1} where T, Base.SubArray{T, 1, P, I, L} where L where I where P where T}, sparams=svec(), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(NLPModels.hess_coord!), Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T), fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000971f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.datatype_npointers), Type{Float16}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c879e940)[Core.MethodMatch(spec_types=Tuple{typeof(Base.datatype_npointers), Type{Float16}}, sparams=svec(), method=datatype_npointers(typeof(DataType)), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000004e2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcastable), Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c0974360)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcastable), Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}}, 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=0x00000000000048a2, 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, Float16, 1} where _A, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94fe7eaba0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Array{ForwardDiff.Dual{Tag, T, 1}, 1} where T where Tag, ForwardDiff.Dual{_A, Float16, 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=0x0000000000001117, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.TupleOrBottom), Type{Float16}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c7d45540)[Core.MethodMatch(spec_types=Tuple{typeof(Base.TupleOrBottom), Type{Float16}}, sparams=svec(), method=TupleOrBottom(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000640, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), Array{Float16, 1}, Any, Any}, limit=3), nothing, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(<=)), Integer, Int64}, 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{Float16, 1}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float16, 1}, Float16}}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fed38300)[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{Float16, 1}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float16, 1}, Float16}}}}}, sparams=svec(Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float16, 1}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float16, 1}, Float16}}}), method=convert(Type{Base.Broadcast.Broadcasted{NewStyle, Axes, F, Args} where Args<:Tuple where F where Axes}, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where var"#s677") where {NewStyle, Axes, F, Args}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047d1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{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{Float16, 1}, Array{Float16, 1}}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cd2159a0)[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{Float16, 1}, Array{Float16, 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=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{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, 0x7f94cca53c80)[Core.MethodMatch(spec_types=Tuple{Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{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(F<:(NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{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)}}), method=(::Type{Base.MappingRF{F, T} where T where F})(F, T) where {F, T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000031e9, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), Array{T, 1} where T<:(ForwardDiff.Dual{T, V, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A) where _A), Array{ForwardDiff.Dual{T, V, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A) where _A}, limit=1), nothing, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.dotgetproperty), CaNNOLeS.CaNNOLeSSolver{Ti, Float64, Array{Float64, 1}, CaNNOLeS.MA57Struct, M} where M<:CaNNOLeS.HessianStruct{Ti} where Ti<:Integer, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fd9cecc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.dotgetproperty), CaNNOLeS.CaNNOLeSSolver{Ti, Float64, Array{Float64, 1}, CaNNOLeS.MA57Struct, M} where M<:CaNNOLeS.HessianStruct{Ti} where Ti<:Integer, Symbol}, sparams=svec(), method=dotgetproperty(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000286, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), ForwardDiff.Dual{T, Float16, _A} where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94cc338e20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), ForwardDiff.Dual{T, Float16, _A} where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)), Int64}, sparams=svec(T<:(ForwardDiff.Dual{T, Float16, N} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where N)), method=setindex!(Array{T, N} where N, Any, Int64) where {T}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001117, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Any, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c50c8cc0)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A, Int64} where N where V where T, sparams=svec(T, V, N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any) where {T, V, N}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ReverseDiff.unseed!), AbstractArray{T, N} where N where T, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94bfab45e0)[ Core.MethodMatch(spec_types=Tuple{typeof(ReverseDiff.unseed!), ReverseDiff.TrackedArray{V, D, N, VA, DA} where DA where VA where N where D where V, Any}, sparams=svec(), method=unseed!(ReverseDiff.TrackedArray{V, D, N, VA, DA} where DA where VA where N where D where V, Any), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(ReverseDiff.unseed!), AbstractArray{T, N} where N where T, Any}, sparams=svec(), method=unseed!(AbstractArray{T, N} where N where T, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"}} where var"#s179"<:Tuple{Array{Int64, 1}, Real}, typeof(Base.:(>)), Tuple{Array{Int64, 1}, Real}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c3a2afa0)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"}} where var"#s179"<:Tuple{Array{Int64, 1}, Real}, typeof(Base.:(>)), Tuple{Array{Int64, 1}, Real}, Tuple{Base.OneTo{Int64}}}, sparams=svec(Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"<:Tuple{Array{Int64, 1}, Real}), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args}})(Any, Any, Any) where {Style, Axes, F, Args}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(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, 0x7f94ca030760)[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=0x00000000000018a5, 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, 0x7f94c9670d40)[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=0x0000000000001246, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Krylov.krylov_solve!), Krylov.CglsWorkspace{T, T, V} where V where T, LinearAlgebra.Adjoint{T, SparseMatricesCOO.SparseMatrixCOO{T, Int64}} where T where T, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94be54a220)[Core.MethodMatch(spec_types=Tuple{typeof(Krylov.krylov_solve!), Krylov.CglsWorkspace{T, T, S}, LinearAlgebra.Adjoint{T, SparseMatricesCOO.SparseMatrixCOO{T, Int64}} where T where T, AbstractArray{T, 1}} where S<:AbstractArray{T, 1} where T<:AbstractFloat, sparams=svec(T<:AbstractFloat, T<:AbstractFloat, S<:AbstractArray{T<:AbstractFloat, 1}), method=krylov_solve!(Krylov.CglsWorkspace{T, FC, S}, Any, AbstractArray{FC, 1}) where {T<:AbstractFloat, FC<:Union{Base.Complex{T}, T}, S<:AbstractArray{FC, 1}}, fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096d1, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cf3baa20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"}, sparams=svec(), method=combine_styles(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004832, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eachindex), Base.IndexLinear, Array{ForwardDiff.Dual{Nothing, Float16, N}, 1} where N, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c35b2260)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), Base.IndexLinear, Array{ForwardDiff.Dual{Nothing, Float16, N}, 1} where N, Array{Float16, 1}}, sparams=svec(), method=eachindex(Base.IndexLinear, AbstractArray{T, N} where N where T, (AbstractArray{T, N} where N where T)...), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000125b, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.string), String, Type{Tuple{2}}, String, Int64, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c4cec3e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.string), String, Type{Tuple{2}}, String, Int64, String}, sparams=svec(), method=string(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003db1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.lastindex), Any}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eachindex), 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=(2,), mem=Memory{Any}(4, 0x7f94c858bca0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), Base.SubArray{_A, 1, P, I, false} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _A}, sparams=svec(), method=eachindex(AbstractArray{T, 1} where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), 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=eachindex(AbstractArray{T, N} where N where T), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001253, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.increment!), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c8c82120)[Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.increment!), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, Symbol}, sparams=svec(), method=increment!(NLPModels.AbstractNLSModel{T, S} where S where T, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096aa, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.cconvert), Type{Ptr{Float16}}, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c0560560)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.cconvert), Type{Ptr{Float16}}, Array{Float16, 1}}, sparams=svec(), method=cconvert(Type{var"#s179"} where var"#s179"<:(Ptr{T} where T), Array{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000c7c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eltype), Type{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}}, limit=4), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94cf853960)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.eltype), Type{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}}, sparams=svec(Float16), method=eltype(Type{var"#s179"} where var"#s179"<:(AbstractArray{E, N} where N)) where {E}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001247, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Tuple{typeof(Base.identity), Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{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)}}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cf7a61e0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Tuple{typeof(Base.identity), Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{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)}}}, Int64}, sparams=svec(), method=getindex(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000669, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.MappingRF{F, T} where T<:Function where F<:Function, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c7db13a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.MappingRF{F, T} where T<:Function where F<:Function, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}), Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94be9e2fa0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(/)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}), Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}, Int64}, sparams=svec(1), method=getindex(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Vararg{Union{Integer, Base.IteratorsMD.CartesianIndex{N} where N}, N}) where {N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000487c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(\)), Tuple{Bool, Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c091c3a0)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(\)), Tuple{Bool, Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}}, Tuple{Int64}}, sparams=svec(), method=(::Type{BoundsError})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000005f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{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.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, Nothing}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fd197560)[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.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, Nothing}, sparams=svec(typeof(Base.:(-))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(CaNNOLeS.try_to_factorize), CaNNOLeS.MA57Struct, Array{T, 1} where T<:Union{Float32, Float64}, Int64, Int64, Int64, Float16}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cd407260)[Core.MethodMatch(spec_types=Tuple{typeof(CaNNOLeS.try_to_factorize), CaNNOLeS.MA57Struct, Array{T, 1} where T<:Union{Float32, Float64}, Int64, Int64, Int64, Float16}, sparams=svec(), method=try_to_factorize(CaNNOLeS.MA57Struct, AbstractArray{T, 1} where T, Integer, Integer, Integer, Real), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096eb, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eachindex), Base.IndexLinear, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c3e07180)[Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), Base.IndexLinear, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}}, sparams=svec(), method=eachindex(Base.IndexStyle, Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047e4, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:(Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{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}, NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64}} where Si where S where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94cf5691e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64}} where Si where S where T}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64}} where Si where S where T} where T<:(Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64}} where Si where S where T), sparams=svec(T), method=convert(Type{T}, T) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000034c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{ReverseDiff.HessianConfig{G, J} where J<:(ReverseDiff.JacobianConfig{I, O} where O where I) where G<:(ReverseDiff.GradientConfig{I} where I)}, Array{Float16, 1}, Type{Float16}, Array{ReverseDiff.AbstractInstruction, 1}, Array{ReverseDiff.AbstractInstruction, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c8fd4ca0)[Core.MethodMatch(spec_types=Tuple{Type{ReverseDiff.HessianConfig{G, J} where J<:(ReverseDiff.JacobianConfig{I, O} where O where I) where G<:(ReverseDiff.GradientConfig{I} where I)}, Array{Float16, 1}, Type{Float16}, Array{ReverseDiff.AbstractInstruction, 1}, Array{ReverseDiff.AbstractInstruction, 1}}, sparams=svec(Float16), method=(::Type{ReverseDiff.HessianConfig{G, J} where J<:(ReverseDiff.JacobianConfig{I, O} where O where I) where G<:(ReverseDiff.GradientConfig{I} where I)})(AbstractArray{T, N} where N where T, Type{D}, Array{ReverseDiff.AbstractInstruction, 1}, Array{ReverseDiff.AbstractInstruction, 1}) where {D}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_result), Type, Type{Tuple{Main.var"#cannoles_tests##18#cannoles_tests##19"{Main.var"#F_under#cannoles_tests##7", Int64}, Main.var"#c_linear#cannoles_tests##10", Array{Float64, 1}, Array{Float64, 1}}}, Any, Type{Union{}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94cca60de0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_result), Type{T}, Type{Tuple{Main.var"#cannoles_tests##18#cannoles_tests##19"{Main.var"#F_under#cannoles_tests##7", Int64}, Main.var"#c_linear#cannoles_tests##10", Array{Float64, 1}, Array{Float64, 1}}}, Type{Union{}}, Type{Union{}}} where T, sparams=svec(T, Tuple{Main.var"#cannoles_tests##18#cannoles_tests##19"{Main.var"#F_under#cannoles_tests##7", Int64}, Main.var"#c_linear#cannoles_tests##10", Array{Float64, 1}, Array{Float64, 1}}), 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{Main.var"#cannoles_tests##18#cannoles_tests##19"{Main.var"#F_under#cannoles_tests##7", Int64}, Main.var"#c_linear#cannoles_tests##10", Array{Float64, 1}, Array{Float64, 1}}}, Type{T}, Type{Union{}}} where T, sparams=svec(T, Union{}), method=promote_result(Type, Type, Type{T}, Type{S}) where {T, S}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000603, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.result_style), Base.Broadcast.DefaultArrayStyle{N} where N, Base.Broadcast.DefaultArrayStyle{0}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94ca5ec760)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.result_style), Base.Broadcast.DefaultArrayStyle{0}, Base.Broadcast.DefaultArrayStyle{0}}, sparams=svec(Base.Broadcast.DefaultArrayStyle{0}), method=result_style(S, S) where {S<:Base.Broadcast.BroadcastStyle}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.result_style), Base.Broadcast.DefaultArrayStyle{N} where N, Base.Broadcast.DefaultArrayStyle{0}}, sparams=svec(), method=result_style(Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004838, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.tail), Tuple{Tuple{Int64, Int64}, Any, Tuple{Int64, Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ccb21f40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.tail), Tuple{Tuple{Int64, Int64}, Any, Tuple{Int64, Int64}}}, sparams=svec(), method=tail(Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000035d, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Generator{I, F} where F where I}, Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##2#__cat_offset1!##3"{Tuple{Bool}, var"#s179", _A}} where _A where var"#s179"<:Tuple{Any}, Base.UnitRange{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c4ac9140)[Core.MethodMatch(spec_types=Tuple{Type{Base.Generator{I, F} where F where I}, Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##2#__cat_offset1!##3"{Tuple{Bool}, var"#s179", _A}} where _A where var"#s179"<:Tuple{Any}, Base.UnitRange{Int64}}, sparams=svec(Base.UnitRange{Int64}, F<:(Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##2#__cat_offset1!##3"{Tuple{Bool}, var"#s179", _A}} where _A where var"#s179"<:Tuple{Any})), method=(::Type{Base.Generator{I, F} where F where I})(F, I) where {I, F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000420, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(-)), AbstractArray{T, 1} where T, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c9e2aca0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(-)), Base.IteratorsMD.CartesianIndices{1, R} where R<:Tuple{Base.OrdinalRange{Int64, Int64}}, Base.IteratorsMD.CartesianIndex{1}}, sparams=svec(1), method=broadcasted(typeof(Base.:(-)), Base.IteratorsMD.CartesianIndices{N, R} where R<:Tuple{Vararg{Base.OrdinalRange{Int64, Int64}, N}}, Base.IteratorsMD.CartesianIndex{N}) where {N}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(-)), AbstractArray{T, 1} where T, Any}, sparams=svec(typeof(Base.:(-))), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004959, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.result_style), Base.Broadcast.DefaultArrayStyle{1}, Base.Broadcast.BroadcastStyle}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94ce53fae0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.result_style), Base.Broadcast.DefaultArrayStyle{1}, Base.Broadcast.DefaultArrayStyle{1}}, sparams=svec(Base.Broadcast.DefaultArrayStyle{1}), method=result_style(S, S) where {S<:Base.Broadcast.BroadcastStyle}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.result_style), Base.Broadcast.DefaultArrayStyle{1}, Base.Broadcast.BroadcastStyle}, sparams=svec(), method=result_style(Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004838, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ColorTypes.comp2), ColorTypes.Colorant{T, N} where N where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7f94ce3471e0)[ Core.MethodMatch(spec_types=Tuple{typeof(ColorTypes.comp2), ColorTypes.Colorant{T, 1} where T}, sparams=svec(), method=comp2(ColorTypes.Colorant{T, 1} where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(ColorTypes.comp2), Union{ColorTypes.AbstractRGB{T} where T, ColorTypes.TransparentColor{C, T, 4} where T where C<:(ColorTypes.AbstractRGB{T} where T)}}, sparams=svec(), method=comp2(Union{ColorTypes.AbstractRGB{T} where T, ColorTypes.TransparentColor{C, T, 4} where T where C<:(ColorTypes.AbstractRGB{T} where T)}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(ColorTypes.comp2), ColorTypes.Colorant{T, N} where N where T}, sparams=svec(), method=comp2(ColorTypes.Colorant{T, N} where N where T), fully_covers=true), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096d6, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.reshape_jacobian), Any, AbstractArray{T, N} where N where T, Array{ForwardDiff.Dual{Nothing, Float16, _A}, 1} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c1c12ae0)[ Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.reshape_jacobian), DiffResults.DiffResult{O, V, D} where D<:Tuple where V where O, AbstractArray{T, N} where N where T, Array{ForwardDiff.Dual{Nothing, Float16, _A}, 1} where _A}, sparams=svec(), method=reshape_jacobian(DiffResults.DiffResult{O, V, D} where D<:Tuple where V where O, Any, Any), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.reshape_jacobian), Any, AbstractArray{T, N} where N where T, Array{ForwardDiff.Dual{Nothing, Float16, _A}, 1} where _A}, sparams=svec(), method=reshape_jacobian(Any, Any, Any), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.indexed_iterate), Tuple{Bool, Tuple{Base.Missing, Any, Base.Missing}}, Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb9d6100)[Core.MethodMatch(spec_types=Tuple{typeof(Base.indexed_iterate), Tuple{Bool, Tuple{Base.Missing, Any, Base.Missing}}, Int64, Int64}, sparams=svec(), method=indexed_iterate(Tuple, Int64, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000689, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A, Array{Float16, 1}, Tuple{Vararg{ForwardDiff.Partials{_A, Float16}, _A}} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c893bb20)[ Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), Array{ForwardDiff.Dual{T, Float16, N}, 1}, Array{Float16, 1}, Tuple{Vararg{ForwardDiff.Partials{N, Float16}, N}}} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), Float16, 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{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A, Array{Float16, 1}, Tuple{Vararg{ForwardDiff.Partials{_A, Float16}, _A}} where _A}, sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), Float16, _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=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ADNLPModels.ADNLSModel!), ADNLPModels.var"#F!#357"{var"#s179", var"#s179"} where var"#s179"<:Integer where var"#s179"<:Function, Array{Float64, 1}, Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fe098e00)[Core.MethodMatch(spec_types=Tuple{typeof(ADNLPModels.ADNLSModel!), ADNLPModels.var"#F!#357"{var"#s179", var"#s179"} where var"#s179"<:Integer where var"#s179"<:Function, Array{Float64, 1}, Integer}, sparams=svec(Array{Float64, 1}), method=ADNLSModel!(Any, S, Integer) where {S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ad, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), 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, 0x7f94c3e6b320)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Int64}, sparams=svec(), method=getindex(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000669, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.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{0}, var"#s179", typeof(Base.identity), Tuple{Int64}} where var"#s179"<:Tuple}, limit=1), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94ca7fc760)[ 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{0}, var"#s179", typeof(Base.identity), Tuple{Int64}} where var"#s179"<:Tuple}, sparams=svec(), method=copyto!(AbstractArray{T, N} where N where T, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"<:Base.Broadcast.AbstractArrayStyle{0}), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048c5, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{BoundsError}, Array{Float16, 2}, Tuple{Int64, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bf493000)[Core.MethodMatch(spec_types=Tuple{Type{BoundsError}, Array{Float16, 2}, 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{Base.Generator{I, F} where F where I}, Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##0#__cat_offset1!##1"{Tuple{Int64}, Tuple{Bool}, Tuple{Int64}, _A}} where _A, Base.UnitRange{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c3223a00)[Core.MethodMatch(spec_types=Tuple{Type{Base.Generator{I, F} where F where I}, Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##0#__cat_offset1!##1"{Tuple{Int64}, Tuple{Bool}, Tuple{Int64}, _A}} where _A, Base.UnitRange{Int64}}, sparams=svec(Base.UnitRange{Int64}, F<:(Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##0#__cat_offset1!##1"{Tuple{Int64}, Tuple{Bool}, Tuple{Int64}, _A}} where _A)), method=(::Type{Base.Generator{I, F} where F where I})(F, I) where {I, F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000420, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), GenericMemoryRef{:not_atomic, ForwardDiff.Dual{Tagψ, T, 1}, Core.AddrSpace{Core}(0x00)} where T where Tagψ, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cde11ae0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), GenericMemoryRef{:not_atomic, ForwardDiff.Dual{Tagψ, T, 1}, Core.AddrSpace{Core}(0x00)} where T where Tagψ, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.aligned_sizeof), Type{UInt8}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f950052eb40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.aligned_sizeof), Type{UInt8}}, sparams=svec(), method=aligned_sizeof(Type), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000004d7, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Any, Int64, Int64}, limit=3), nothing, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Base.var"#view##0#view##1"{Base.SubArray{Float16, 1, Array{Float16, 1}, I, false}} where I<:Tuple{Array{T, 1} where T<:Integer}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bf6dc740)[Core.MethodMatch(spec_types=Tuple{Base.var"#view##0#view##1"{Base.SubArray{Float16, 1, Array{Float16, 1}, I, false}} where I<:Tuple{Array{T, 1} where T<:Integer}, Int64}, sparams=svec(), method=(::Base.var"#view##0#view##1"{A})(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002dd5, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isempty), Array{_A, 1} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94fdbd5660)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.isempty), Array{_A, 1} where _A}, sparams=svec(), method=isempty(AbstractArray{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012c4, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Base.Iterators.Zip{Is} where Is<:Tuple{Base.OneTo{Int64}, Any, Base.OneTo{Int64}}, Tuple{Int64, Any, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ca966100)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Base.Iterators.Zip{Is} where Is<:Tuple{Base.OneTo{Int64}, Any, Base.OneTo{Int64}}, Tuple{Int64, Any, Int64}}, sparams=svec(), method=iterate(Base.Iterators.Zip{Is} where Is<:Tuple, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000018c2, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:x0,), Tuple{Array{Float64, 1}}}, Any, Int64, ADNLPModels.var"#26#27", Integer, ADNLPModels.var"#F!#357"{var"#s179", var"#s179"} where var"#s179"<:Integer where var"#s179"<:Function}, limit=3), nothing, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.extract_jacobian_chunk!), Type{Nothing}, Any, AbstractArray{T, N} where N where T, Int64, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cec89000)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.extract_jacobian_chunk!), Type{Nothing}, Any, AbstractArray{T, N} where N where T, Int64, Any}, sparams=svec(Nothing), method=extract_jacobian_chunk!(Type{T}, Any, Any, Any, Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:init,), Tuple{Int64}}, typeof(Base.mapfoldl), Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}, typeof(Base.add_sum), Base.Generator{Array{Int64, 1}, F} where F<:(NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{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, 0x7f94cf4fc600)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:init,), Tuple{Int64}}, typeof(Base.mapfoldl), Base.var"#_bool##0#_bool##1"{typeof(Base.identity)}, typeof(Base.add_sum), Base.Generator{Array{Int64, 1}, F} where F<:(NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{T, S, Si}, Array{Int64, 1}, Int64} where Si where S where T)}, sparams=svec(), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(Base.mapfoldl), Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003201, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.dotgetproperty), SparseMatricesCOO.SparseMatrixCOO{Float64, Ti} where Ti<:Integer, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fe467500)[Core.MethodMatch(spec_types=Tuple{typeof(Base.dotgetproperty), SparseMatricesCOO.SparseMatrixCOO{Float64, Ti} where Ti<:Integer, Symbol}, sparams=svec(), method=dotgetproperty(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000286, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_type), Type, Type{Tuple{Main.var"#F_linear#cannoles_tests##0", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7f94ccab1460)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_type), Type{Union{}}, Type{Tuple{Main.var"#F_linear#cannoles_tests##0", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}}, sparams=svec(Tuple{Main.var"#F_linear#cannoles_tests##0", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}), method=promote_type(Type{Union{}}, Type{T}) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_type), Type{Tuple{Main.var"#F_linear#cannoles_tests##0", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}, Type{Tuple{Main.var"#F_linear#cannoles_tests##0", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}}, sparams=svec(Tuple{Main.var"#F_linear#cannoles_tests##0", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}), method=promote_type(Type{T}, Type{T}) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_type), Type, Type{Tuple{Main.var"#F_linear#cannoles_tests##0", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}}, sparams=svec(T, Tuple{Main.var"#F_linear#cannoles_tests##0", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}), method=promote_type(Type{T}, Type{S}) where {T, S}, fully_covers=true), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000005f9, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkindex), Type{Bool}, Base.OneTo{Int64}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c82a7540)[Core.MethodMatch(spec_types=Tuple{typeof(Base.checkindex), Type{Bool}, Base.OneTo{Int64}, Int64}, sparams=svec(Int64), method=checkindex(Type{Bool}, Base.OneTo{T}, T) where {T<:Union{Int128, Int16, Int32, Int64, Int8, UInt128, UInt16, UInt32, UInt64, UInt8}}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001286, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}}, Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.:(&)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float16, 1}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float16, 1}, Float16}}}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c3ee25c0)[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.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float16, 1}, Float16}}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(var"==")), Tuple{Array{Float16, 1}, Float16}}}, Tuple{Base.OneTo{Int64}}}, sparams=svec(typeof(Base.:(&))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Krylov.var"##cgls!#133", LinearAlgebra.UniformScaling{Bool}, Bool, Float16, Float16, Float16, Float16, Int64, Float64, Int64, Bool, Krylov.var"#krylov_solve!##200#krylov_solve!##201", Core.CoreSTDOUT, typeof(Krylov.cgls!), Krylov.CglsWorkspace{Float16, Float16, Array{Float16, 1}}, LinearAlgebra.Adjoint{Float16, SparseMatricesCOO.SparseMatrixCOO{Float16, Ti}} where Ti<:Integer, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c7e7c920)[Core.MethodMatch(spec_types=Tuple{Krylov.var"##cgls!#133", LinearAlgebra.UniformScaling{Bool}, Bool, Float16, Float16, Float16, Float16, Int64, Float64, Int64, Bool, Krylov.var"#krylov_solve!##200#krylov_solve!##201", Core.CoreSTDOUT, typeof(Krylov.cgls!), Krylov.CglsWorkspace{Float16, Float16, Array{Float16, 1}}, LinearAlgebra.Adjoint{Float16, SparseMatricesCOO.SparseMatrixCOO{Float16, Ti}} where Ti<:Integer, Array{Float16, 1}}, sparams=svec(Float16, Float16, Array{Float16, 1}), method=var"#cgls!#133"(Any, Bool, T, T, T, T, Int64, Float64, Int64, Bool, Any, IO, typeof(Krylov.cgls!), Krylov.CglsWorkspace{T, FC, S}, Any, AbstractArray{FC, 1}) where {T<:AbstractFloat, FC<:Union{Base.Complex{T}, T}, S<:AbstractArray{FC, 1}}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096d1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Base.UnitRange{Int64}}, true}, Any}, limit=1), nothing, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.rem), Int64, Type{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c884b760)[Core.MethodMatch(spec_types=Tuple{typeof(Base.rem), Int64, Type{Int64}}, sparams=svec(Int64), method=rem(T, Type{T}) where {T<:Integer}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000b6d, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Extruded{T, K, D} where D where K where T}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{Bool}, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0a4b1e0)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Extruded{T, K, D} where D where K where T}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{Bool}, Tuple{Int64}}, sparams=svec(Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{Bool}, Tuple{Int64}), method=(::Type{Base.Broadcast.Extruded{T, K, D} where D where K where T})(T, K, D) where {T, K, D}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000488f, 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, 0x7f94c2b753a0)[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=0x00000000000048c7, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.unsafe_wrap), Type{Memory{UInt8}}, String}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c4682720)[Core.MethodMatch(spec_types=Tuple{typeof(Base.unsafe_wrap), Type{Memory{UInt8}}, String}, sparams=svec(), method=unsafe_wrap(Type{Memory{UInt8}}, String), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003710, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base._collect), Base.UnitRange{Int64}, ColorTypes.ComponentIterator{C} where C<:(Union{ColorTypes.AlphaColor{Cb, T, N} where N where T, ColorTypes.ColorAlpha{Cb, T, N} where N where T, Cb} where Cb<:Union{ColorTypes.HSI{T} where T<:AbstractFloat, ColorTypes.HSL{T} where T<:AbstractFloat, ColorTypes.HSV{T} where T<:AbstractFloat, ColorTypes.LCHab{T} where T<:AbstractFloat, ColorTypes.LCHuv{T} where T<:AbstractFloat, ColorTypes.Oklch{T} where T<:AbstractFloat}), Base.HasEltype, Base.HasLength}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bec77dc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base._collect), Base.UnitRange{Int64}, ColorTypes.ComponentIterator{C} where C<:(Union{ColorTypes.AlphaColor{Cb, T, N} where N where T, ColorTypes.ColorAlpha{Cb, T, N} where N where T, Cb} where Cb<:Union{ColorTypes.HSI{T} where T<:AbstractFloat, ColorTypes.HSL{T} where T<:AbstractFloat, ColorTypes.HSV{T} where T<:AbstractFloat, ColorTypes.LCHab{T} where T<:AbstractFloat, ColorTypes.LCHuv{T} where T<:AbstractFloat, ColorTypes.Oklch{T} where T<:AbstractFloat}), Base.HasEltype, Base.HasLength}, sparams=svec(), method=_collect(Any, Any, Base.HasEltype, Union{Base.HasLength, Base.HasShape{N} where N}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010f7, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.kwerr), NamedTuple{names, T} where T<:Tuple where names, typeof(NLPModels.hess_coord!), Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, Array{T, N} where N where T, AbstractArray{T, 1} 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=(1,), mem=Memory{Any}(1, 0x7f94cb8fbc40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.kwerr), NamedTuple{names, T} where T<:Tuple where names, typeof(NLPModels.hess_coord!), Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, Array{T, N} where N where T, AbstractArray{T, 1} where T, Base.SubArray{T, N, P, I, L} where L where I where P where N where T}, sparams=svec(5), method=kwerr(Any, Vararg{Any, N}) where {N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000009d0, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.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{Float16, 1}, Float16}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cd77ce20)[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{Float16, 1}, Float16}}, sparams=svec(typeof(Base.:(/))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setdiff), Any, Array{Int64, 1}}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(DiffResults.value!), ForwardDiff.var"#extract_value!##0#extract_value!##1"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function), DiffResults.DiffResult{O, V, D} where D<:Tuple where V where O, AbstractArray{T, N} where N where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c0675f60)[ Core.MethodMatch(spec_types=Tuple{typeof(DiffResults.value!), ForwardDiff.var"#extract_value!##0#extract_value!##1"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function), DiffResults.MutableDiffResult{O, V, D} where D<:Tuple where V where O, AbstractArray{T, N} where N where T}, sparams=svec(), method=value!(Any, DiffResults.MutableDiffResult{O, V, D} where D<:Tuple where V where O, AbstractArray{T, N} where N where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(DiffResults.value!), ForwardDiff.var"#extract_value!##0#extract_value!##1"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function), DiffResults.ImmutableDiffResult{O, V, D} where D<:Tuple, AbstractArray{T, N} where N where T} where V where O, sparams=svec(O, V), method=value!(Any, DiffResults.ImmutableDiffResult{O, V, D} where D<:Tuple, AbstractArray{T, N} where N where T) where {O, V}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009687, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{ForwardDiff.HessianConfig{T, V, N, DG, DJ} where DJ where DG where N where V where T}, Function, Array{Float16, 1}, ForwardDiff.Chunk{N} where N, ForwardDiff.Tag{F, Float16} where F<:Function}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c09f8780)[Core.MethodMatch(spec_types=Tuple{Type{ForwardDiff.HessianConfig{T, V, N, DG, DJ} where DJ where DG where N where V where T}, Function, Array{Float16, 1}, ForwardDiff.Chunk{N} where N, ForwardDiff.Tag{F, Float16} where F<:Function}, sparams=svec(F<:Function, Float16), method=(::Type{ForwardDiff.HessianConfig{T, V, N, DG, DJ} where DJ where DG where N where V where T})(F, AbstractArray{V, N} where N, ForwardDiff.Chunk{N} where N, Any) where {F, V}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c3d82660)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.collect_to!), Array{_A, 1} where _A, Base.Generator{Base.UnitRange{Int64}, F} where F<:(Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##2#__cat_offset1!##3"{Tuple{Bool}, Tuple{Int64}, _A}} where _A), Int64, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c388f540)[Core.MethodMatch(spec_types=Tuple{typeof(Base.collect_to!), Array{_A, 1} where _A, Base.Generator{Base.UnitRange{Int64}, F} where F<:(Base.var"#_ntuple##0#_ntuple##1"{Base.var"#__cat_offset1!##2#__cat_offset1!##3"{Tuple{Bool}, Tuple{Int64}, _A}} where _A), Int64, Int64}, sparams=svec(_A), method=collect_to!(AbstractArray{T, N} where N, Any, Any, Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000110a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{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{Float16, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cedf03c0)[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{Float16, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, Tuple{Base.OneTo{Int64}}}, sparams=svec(typeof(Base.:(*))), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}})(Union{Nothing, Base.Broadcast.BroadcastStyle}, F, Tuple, Any) where {F}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_result), Type{Tuple{Function, Function, Array{Float64, 1}, Array{Float64, 1}}}, Type{Tuple{Main.var"#cannoles_tests##22#cannoles_tests##23"{Main.var"#F_larger#cannoles_tests##2"}, Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}, Type{Union{}}, Type{Union{}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ffa20040)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_result), Type{Tuple{Function, Function, Array{Float64, 1}, Array{Float64, 1}}}, Type{Tuple{Main.var"#cannoles_tests##22#cannoles_tests##23"{Main.var"#F_larger#cannoles_tests##2"}, Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}, Type{Union{}}, Type{Union{}}}, sparams=svec(Tuple{Function, Function, Array{Float64, 1}, Array{Float64, 1}}, Tuple{Main.var"#cannoles_tests##22#cannoles_tests##23"{Main.var"#F_larger#cannoles_tests##2"}, Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}), method=promote_result(Type{T}, Type{S}, Type{Union{}}, Type{Union{}}) where {T, S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000603, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.mightalias), Array{Float16, 1}, Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c0643ea0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.mightalias), Array{Float16, 1}, Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<: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=0x0000000000001312, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:(ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A))), ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A))}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94cc2090e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A))}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A))} where T<:(ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A))), sparams=svec(T), method=convert(Type{T}, T) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000034c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(+)), Integer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(6, 0x7f94c1e69510)[ 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=0x00000000000061ba, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.afoldl), Base.var"#promote_eltypeof##0#promote_eltypeof##1", Type{Tuple{Function, Main.var"#c_linear#cannoles_tests##10", Array{Float64, 1}, Array{Float64, 1}}}, Tuple{Main.var"#cannoles_tests##18#cannoles_tests##19"{Main.var"#F_under#cannoles_tests##7", Int64}, Main.var"#c_linear#cannoles_tests##10", Array{Float64, 1}, Array{Float64, 1}}, Tuple{Main.var"#F_linear#cannoles_tests##0", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}, Tuple{Main.var"#F_Rosen#cannoles_tests##1", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}, Tuple{Main.var"#cannoles_tests##22#cannoles_tests##23"{Main.var"#F_larger#cannoles_tests##2"}, Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ff024480)[Core.MethodMatch(spec_types=Tuple{typeof(Base.afoldl), Base.var"#promote_eltypeof##0#promote_eltypeof##1", Type{Tuple{Function, Main.var"#c_linear#cannoles_tests##10", Array{Float64, 1}, Array{Float64, 1}}}, Tuple{Main.var"#cannoles_tests##18#cannoles_tests##19"{Main.var"#F_under#cannoles_tests##7", Int64}, Main.var"#c_linear#cannoles_tests##10", Array{Float64, 1}, Array{Float64, 1}}, Tuple{Main.var"#F_linear#cannoles_tests##0", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}, Tuple{Main.var"#F_Rosen#cannoles_tests##1", Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}, Tuple{Main.var"#cannoles_tests##22#cannoles_tests##23"{Main.var"#F_larger#cannoles_tests##2"}, Main.var"#c_quad#cannoles_tests##11", Array{Float64, 1}, Array{Float64, 1}}}, sparams=svec(), method=afoldl(Any, Any, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000bf0, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.:(>)), Array{Int64, 1}, Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c5487320)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Base.Broadcast.DefaultArrayStyle{1}, typeof(Base.:(>)), Array{Int64, 1}, Real}, sparams=svec(typeof(Base.:(>))), method=broadcasted(Base.Broadcast.BroadcastStyle, F, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000495a, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.increment!), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, Base.Val{:neval_jac_residual}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c801c3a0)[Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.increment!), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, Base.Val{:neval_jac_residual}}, sparams=svec(), method=increment!(NLPModels.AbstractNLSModel{T, S} where S where T, Base.Val{:neval_jac_residual}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096aa, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LinearAlgebra.dot), Any, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, limit=3), nothing, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto_axcheck!), Array{Float16, 1}, Array{T, 1} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c55472c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.copyto_axcheck!), Array{Float16, 1}, Array{T, 1} where T}, sparams=svec(), method=copyto_axcheck!(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012b7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), Any, ForwardDiff.var"#partials_wrap#extract_jacobian_chunk!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)), Any, Any}, limit=3), nothing, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ReverseDiff.extract_result!), Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, ReverseDiff.TrackedReal{V, D, O} where O where D<:Real where V<:Real, ReverseDiff.TrackedArray{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bfa70160)[Core.MethodMatch(spec_types=Tuple{typeof(ReverseDiff.extract_result!), Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, ReverseDiff.TrackedReal{V, D, O} where O where D<:Real where V<:Real, ReverseDiff.TrackedArray{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}}}, sparams=svec(), method=extract_result!(AbstractArray{T, N} where N where T, ReverseDiff.TrackedReal{V, D, O} where O where D<:Real where V<:Real, ReverseDiff.TrackedArray{V, D, N, VA, DA} where DA where VA where N where D where V), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:x0,), Tuple{Array{Float16, 1}}}, typeof(ADNLPModels.ADModelNLSBackend), Int64, Function, Int64, Int64, ADNLPModels.var"#c!#370"{Main.var"#c_linear#cannoles_tests##10"}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c8d2cf00)[Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:x0,), Tuple{Array{Float16, 1}}}, typeof(ADNLPModels.ADModelNLSBackend), Int64, Function, Int64, Int64, ADNLPModels.var"#c!#370"{Main.var"#c_linear#cannoles_tests##10"}}, sparams=svec(), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(ADNLPModels.ADModelNLSBackend), Integer, Any, Integer, Integer, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ad, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{ForwardDiff.JacobianConfig{Nothing, Float16, _A, Array{ForwardDiff.Dual{Nothing, Float16, _A}, 1}}} where _A where _A, Any, Array{ForwardDiff.Dual{Nothing, Float16, _A}, 1} where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c1f76900)[Core.MethodMatch(spec_types=Tuple{Type{ForwardDiff.JacobianConfig{Nothing, Float16, _A, Array{ForwardDiff.Dual{Nothing, Float16, _A}, 1}}} where _A where _A, Any, Array{ForwardDiff.Dual{Nothing, Float16, _A}, 1} where _A}, sparams=svec(), method=(::Type{ForwardDiff.JacobianConfig{T, V, N, D}})(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), CaNNOLeS.LDLFactStruct{T, Ti} where Ti<:Integer where T, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c47dfbe0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), CaNNOLeS.LDLFactStruct{T, Ti} where Ti<:Integer where T, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}} where var"#s179"<:Tuple, Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fcf45080)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._axes), Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Array{Float16, 1}, Tuple{Bool}, Tuple{Int64}}}} where var"#s179"<:Tuple, Tuple}, sparams=svec(), method=_axes(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}, Tuple), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047da, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.extract_jacobian!), Type{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)), Any, AbstractArray{T, N} where N where T, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94ff5773e0)[ Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.extract_jacobian!), Type{T}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T, Int64} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)), sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c))), method=extract_jacobian!(Type{T}, AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T, Any) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.extract_jacobian!), Type{T}, DiffResults.MutableDiffResult{O, V, D} where D<:Tuple where V where O, AbstractArray{T, N} where N where T, Int64} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)), sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c))), method=extract_jacobian!(Type{T}, DiffResults.MutableDiffResult{O, V, D} where D<:Tuple where V where O, AbstractArray{T, N} where N where T, Any) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LDLFactorizations.ldl_solve!), Integer, Array{Float16, 1}, Array{Ti, 1} where Ti<:Integer, Array{Ti, 1} where Ti<:Integer, Array{Float16, 1}, Array{Float16, 1}, Array{Ti, 1} where Ti<:Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c8117320)[Core.MethodMatch(spec_types=Tuple{typeof(LDLFactorizations.ldl_solve!), Integer, Array{Float16, 1}, Array{Ti, 1} where Ti<:Integer, Array{Ti, 1} where Ti<:Integer, Array{Float16, 1}, Array{Float16, 1}, Array{Ti, 1} where Ti<:Integer}, sparams=svec(), method=ldl_solve!(Any, AbstractArray{T, 1} where T, Any, Any, Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096d3, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.jac_coord_residual!), NLPModels.AbstractNLPModel{T, S} where S where T, Array{Float16, 1}, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7f94ce7eb120)[ Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_coord_residual!), Main.MGH01CON{T, S} where S where T, Array{Float16, 1}, Array{Float16, 1}}, sparams=svec(), method=jac_coord_residual!(Main.MGH01CON{T, S} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_coord_residual!), Main.MGH01_noFHess{T, S} where S where T, Array{Float16, 1}, Array{Float16, 1}}, sparams=svec(), method=jac_coord_residual!(Main.MGH01_noFHess{T, S} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_coord_residual!), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, Array{Float16, 1}, Array{Float16, 1}}, sparams=svec(), method=jac_coord_residual!(ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T), fully_covers=false), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009704, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._getindex), Base.IndexLinear, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c3e050c0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._getindex), Base.IndexLinear, Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Base.Broadcast.Extruded{Array{Int64, 1}, Tuple{Bool}, Tuple{Int64}}, Real}, Int64}, sparams=svec(), method=_getindex(Base.IndexStyle, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000487e, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{ReverseDiff.TrackedArray{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}}}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.AbstractInstruction, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c33f93c0)[Core.MethodMatch(spec_types=Tuple{Type{ReverseDiff.TrackedArray{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}}}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.AbstractInstruction, 1}}, sparams=svec(ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}), method=(::Type{ReverseDiff.TrackedArray{V, D, N, VA, DA}})(AbstractArray{V, N}, AbstractArray{D, N}, Array{ReverseDiff.AbstractInstruction, 1}) where {V, D, N, VA, DA}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.CanonicalIndexError}, String, Type{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cbea28a0)[Core.MethodMatch(spec_types=Tuple{Type{Base.CanonicalIndexError}, String, Type{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}}, sparams=svec(), method=(::Type{Base.CanonicalIndexError})(String, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012d6, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(LinearAlgebra.mat_vec_scalar), SparseMatricesCOO.SparseMatrixCOO{Float16, Ti} where Ti<:Integer, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Float16}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c33b8320)[Core.MethodMatch(spec_types=Tuple{typeof(LinearAlgebra.mat_vec_scalar), SparseMatricesCOO.SparseMatrixCOO{Float16, Ti} where Ti<:Integer, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Float16}, sparams=svec(), method=mat_vec_scalar(Any, Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000007f6d, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.seed!), Any, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A, Tuple{Vararg{ForwardDiff.Partials{N, ForwardDiff.Dual{T, V, N}}, N}} where N where V where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94cc9faf20)[ Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.seed!), AbstractArray{ForwardDiff.Dual{T, ForwardDiff.Dual{T, V, N}, N}, N} where N, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A, Tuple{Vararg{ForwardDiff.Partials{N, ForwardDiff.Dual{T, V, N}}, N}}} where N where T where V where T, sparams=svec(T, V<:(ForwardDiff.Dual{T, V, N} where T where V where N), 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!), AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A, Tuple{Vararg{ForwardDiff.Partials{N, ForwardDiff.Dual{T, V, N}}, N}} where N where V where T} where N where V where T, sparams=svec(T, V, N), method=seed!(AbstractArray{ForwardDiff.Dual{T, V, N}, N} where N, Any, Any) where {T, V, N}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Iterators.zip), Any, Base.Iterators.Drop{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ce6a1340)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators.zip), Any, Base.Iterators.Drop{Base.OneTo{Int64}}}, sparams=svec(), method=zip(Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000018a5, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), Any, ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94cc0152e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Base.Broadcast.BroadcastStyle, F, Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}} where F<:(ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A))), sparams=svec(F<:F<:(ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)))), method=broadcasted(Base.Broadcast.BroadcastStyle, F, Any...) where {F}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), Any, ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}}, sparams=svec(F), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000495a, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.increment!), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, Base.Val{:neval_jac_nln}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94be83ca40)[Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.increment!), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, Base.Val{:neval_jac_nln}}, sparams=svec(), method=increment!(NLPModels.AbstractNLSModel{T, S} where S where T, Base.Val{:neval_jac_nln}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096aa, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.structural_eachindex), AbstractArray{ForwardDiff.Dual{T, ForwardDiff.Dual{T, V, N}, N}, N} where N where N where T where V where T, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), Base.var"#__cat_offset1!##0#__cat_offset1!##1"{Tuple{Int64}, Tuple{Bool}, var"#s179", _A} where _A where var"#s179"<:Tuple{Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c4202800)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), Base.var"#__cat_offset1!##0#__cat_offset1!##1"{Tuple{Int64}, Tuple{Bool}, var"#s179", _A} where _A where var"#s179"<:Tuple{Any}}, sparams=svec(), method=Typeof(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000028, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.checkbounds), Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{Bool}, Tuple{Int64}}}} where var"#s179"<:Tuple, Base.IteratorsMD.CartesianIndex{2}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb35bbc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.checkbounds), Base.Broadcast.Broadcasted{Nothing, var"#s179", typeof(Base.identity), Tuple{Base.Broadcast.Extruded{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Tuple{Bool}, Tuple{Int64}}}} where var"#s179"<:Tuple, 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=0x0000000000004885, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), Array{Any, 1}, Type{Main.var"#cannoles_tests##16#cannoles_tests##17"{Main.var"#F_under#cannoles_tests##7", Int64}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ccf2bb20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.setindex!), Array{Any, 1}, Type{Main.var"#cannoles_tests##16#cannoles_tests##17"{Main.var"#F_under#cannoles_tests##7", Int64}}, Int64}, sparams=svec(), method=setindex!(Array{Any, N} where N, Any, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000039b, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IndexStyle}, Type{Array{Float16, 2}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c03e8160)[ Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Type{Array{Float16, 2}}}, sparams=svec(), method=(::Type{Base.IndexStyle})(Type{var"#s179"} where var"#s179"<:(Array{T, N} where N where T)), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000fa7, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IndexStyle}, Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:Function), Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c07af9a0)[Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Array{ForwardDiff.Dual{T, Float16, N}, 1} where N where T<:(ForwardDiff.Tag{F, Float16} where F<:Function), Array{Float16, 1}}, sparams=svec(), method=(::Type{Base.IndexStyle})(AbstractArray{T, N} where N where T, AbstractArray{T, N} where N where T), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000fa9, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.nteltype), Type{NamedTuple{(:x0,), Tuple{Array{Float16, 1}}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c80fef40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.nteltype), Type{NamedTuple{(:x0,), Tuple{Array{Float16, 1}}}}}, sparams=svec(Tuple{Array{Float16, 1}}), method=nteltype(Type{NamedTuple{names, T}} where names) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001a7d, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.isempty), Array{ForwardDiff.Dual{Tagψ, T, 1}, 1} where T where Tagψ}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c10aa9a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.isempty), Array{ForwardDiff.Dual{Tagψ, T, 1}, 1} where T where Tagψ}, sparams=svec(), method=isempty(AbstractArray{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012c4, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{ForwardDiff.Tag{F, V} where V where F}, Function, Type{Float16}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0a42bc0)[Core.MethodMatch(spec_types=Tuple{Type{ForwardDiff.Tag{F, V} where V where F}, Function, Type{Float16}}, sparams=svec(F<:Function, Float16), method=(::Type{ForwardDiff.Tag{F, V} where V where F})(F, Type{V}) where {F, V}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{NamedTuple{(:linsolve, :verbose), T} where T<:Tuple}, Tuple{Symbol, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fd2de940)[Core.MethodMatch(spec_types=Tuple{Type{NamedTuple{(:linsolve, :verbose), T} where T<:Tuple}, Tuple{Symbol, Int64}}, sparams=svec((:linsolve, :verbose)), method=(::Type{NamedTuple{names, T} where T<:Tuple})(Tuple) where {names}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000183, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.SubArray{T, N, P, I, L} where L where I where P where N where T}, Base.IndexCartesian, Array{Float16, 1}, Tuple{Array{Int64, 1}}, Tuple{Bool}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cd66e520)[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{Float16, 1}, Tuple{Array{Int64, 1}}, Tuple{Bool}}, sparams=svec(Array{Float16, 1}, Tuple{Array{Int64, 1}}, 1), method=(::Type{Base.SubArray{T, N, P, I, L} where L where I where P where N where T})(Base.IndexCartesian, P, I, Tuple{Vararg{Any, N}}) where {P, I, N}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000002d92, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(/)), Any, Any}, limit=3), nothing, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.mightalias), Array{ForwardDiff.Dual{Tagψ, T, 1}, 1} where T where Tagψ, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c10a99e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.mightalias), Array{ForwardDiff.Dual{Tagψ, T, 1}, 1} where T where Tagψ, Array{Float16, 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=0x0000000000001312, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IndexStyle}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c18e9a20)[ Core.MethodMatch(spec_types=Tuple{Type{Base.IndexStyle}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}}, sparams=svec(), method=(::Type{Base.IndexStyle})(AbstractArray{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000fa4, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{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, 0x7f94fcf236e0)[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=0x0000000000000183, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize!), 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), Tuple{Array{Float16, 1}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94cbda2f60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize!), 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), Tuple{Array{Float16, 1}}}}, sparams=svec(), method=materialize!(Any, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048be, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94cbd7bde0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)), Any, LinearAlgebra.Transpose{Int64, Base.UnitRange{Int64}}}, sparams=svec(F<:(ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)))), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004959, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Array{Int64, 1}, Real}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94fcb86d20)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(>)), var"#s179"} where var"#s179"<:Tuple{Array{Int64, 1}, Real}}, sparams=svec(), method=materialize(Base.Broadcast.Broadcasted{Style, Axes, F, Args} where Args<:Tuple where F where Axes where Style<:Union{Nothing, Base.Broadcast.BroadcastStyle}), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048ba, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.preprocess), Base.BitArray{1}, Real}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c3b19ee0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.preprocess), Base.BitArray{1}, Real}, sparams=svec(), method=preprocess(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048cb, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, _A, typeof(Base.identity), Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}} where _A, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ce25bd20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, _A, typeof(Base.identity), Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}} where _A, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Iterators._zip_isdone), Tuple{Any, Base.OneTo{Int64}}, Tuple{Tuple{Any}, Tuple{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cc32b2a0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Iterators._zip_isdone), Tuple{Any, Base.OneTo{Int64}}, Tuple{Tuple{Any}, Tuple{Int64}}}, sparams=svec(), method=_zip_isdone(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000018ce, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.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{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cf7367e0)[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{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}}}, sparams=svec(Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.identity), Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}), method=convert(Type{Base.Broadcast.Broadcasted{NewStyle, Axes, F, Args} where Args<:Tuple where F where Axes}, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where var"#s677") where {NewStyle, Axes, F, Args}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047d1, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{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, 0x7f94cdff5180)[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.ADNLSModel{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.maybeconstructor), Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{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, 0x7f94ce11aba0)[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.ADNLSModel{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=0x0000000000000c37, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), ForwardDiff.HessianConfig{T, Float16, _A, DG, DJ} where DJ<:(Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A) where DG<:(Array{ForwardDiff.Dual{T, V, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A) where _A) where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A))}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb65ea40)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), ForwardDiff.HessianConfig{T, Float16, _A, DG, DJ} where DJ<:(Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A) where DG<:(Array{ForwardDiff.Dual{T, V, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A) where _A) where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A))}, sparams=svec(), method=Typeof(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000028, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.iterate), Base.Iterators.Zip{Is} where Is<:Tuple{Base.UnitRange{Int64}, Base.Iterators.Drop{I} where I}, Tuple{Int64, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cc949360)[Core.MethodMatch(spec_types=Tuple{typeof(Base.iterate), Base.Iterators.Zip{Is} where Is<:Tuple{Base.UnitRange{Int64}, Base.Iterators.Drop{I} where I}, Tuple{Int64, Any}}, sparams=svec(), method=iterate(Base.Iterators.Zip{Is} where Is<:Tuple, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000018c2, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast._getindex), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c44f3840)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast._getindex), Tuple{Base.Broadcast.Extruded{T, Tuple{Bool}, Tuple{Int64}} where T<:(Array{_A, 1} where _A)}, Int64}, sparams=svec(), method=_getindex(Tuple{Any}, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000489b, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Any}, limit=1), nothing, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.preprocess_args), Base.SubArray{_A, _B, P, I, true} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A, Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb482a40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.preprocess_args), Base.SubArray{_A, _B, P, I, true} where I<:Tuple where P<:(AbstractArray{T, N} where N where T) where _B where _A, Tuple{Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}}, sparams=svec(), method=preprocess_args(Any, Tuple{Any}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048ce, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:x, :verbose), Tuple{Array{Float16, 1}, Int64}}, typeof(SolverCore.solve!), CaNNOLeS.CaNNOLeSSolver{Ti, Float16, Array{Float16, 1}, CaNNOLeS.MA57Struct, _A} where _A where Ti<:Integer, ADNLPModels.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}, SolverCore.GenericExecutionStats{Float16, Array{Float16, 1}, Array{Float16, 1}, Any}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94cf496720)[ Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:x, :verbose), Tuple{Array{Float16, 1}, Int64}}, typeof(SolverCore.solve!), CaNNOLeS.CaNNOLeSSolver{Ti, Float16, Array{Float16, 1}, CaNNOLeS.MA57Struct, M}, ADNLPModels.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}, SolverCore.GenericExecutionStats{Float16, Array{Float16, 1}, Array{Float16, 1}, Any}} where M<:CaNNOLeS.HessianStruct{Ti} where Ti<:Integer, sparams=svec(Ti<:Integer, Float16, Array{Float16, 1}, CaNNOLeS.MA57Struct, M<:CaNNOLeS.HessianStruct{Ti<:Integer}), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(SolverCore.solve!), CaNNOLeS.CaNNOLeSSolver{Ti, T, V, F, M}, NLPModels.AbstractNLSModel{T, V}, SolverCore.GenericExecutionStats{T, V, V, Tsp} where Tsp) where {Ti, T, V, F, M<:CaNNOLeS.HessianStruct{Ti}}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:x, :verbose), Tuple{Array{Float16, 1}, Int64}}, typeof(SolverCore.solve!), CaNNOLeS.CaNNOLeSSolver{Ti, Float16, Array{Float16, 1}, CaNNOLeS.MA57Struct, _A} where _A where Ti<:Integer, ADNLPModels.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}, SolverCore.GenericExecutionStats{Float16, Array{Float16, 1}, Array{Float16, 1}, Any}}, sparams=svec(), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(SolverCore.solve!), SolverCore.AbstractOptimizationSolver, NLPModels.AbstractNLPModel{T, S} where S where T, SolverCore.GenericExecutionStats{T, S, V, Tsp} where Tsp where V where S where T), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096eb, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:obj_weight,), Tuple{Float16}}, typeof(NLPModels.hess_coord!), NLPModels.AbstractNLPModel{T, S} where S where T, Array{Float16, 1}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c0bbf4a0)[ Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:obj_weight,), Tuple{Float16}}, typeof(NLPModels.hess_coord!), Main.MGH01CON{T, S} where S where T, Array{Float16, 1}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(Float16), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(NLPModels.hess_coord!), Main.MGH01CON{T, S} where S where T, AbstractArray{T, 1}, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T) where {T}, fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Core.kwcall), NamedTuple{(:obj_weight,), Tuple{Float16}}, typeof(NLPModels.hess_coord!), Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, Array{Float16, 1}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(), method=kwcall(NamedTuple{names, T} where T<:Tuple where names, typeof(NLPModels.hess_coord!), Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T), fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000971f, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.throw_boundserror), Array{ForwardDiff.Dual{T, Float16, N}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where N, Tuple{Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f9500112da0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.throw_boundserror), Array{ForwardDiff.Dual{T, Float16, N}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where N, Tuple{Int64}}, sparams=svec(), method=throw_boundserror(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000310, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.argtail), typeof(Base.identity), Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{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, 0x7f94ce16ad40)[Core.MethodMatch(spec_types=Tuple{typeof(Base.argtail), typeof(Base.identity), Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##2#jac_structure!##3"{ADNLPModels.ADNLSModel{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=argtail(Any, Any...), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000035b, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{var"#s175"} where var"#s175"<:(Memory{ForwardDiff.Dual{T, Float16, _A}} where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A))), UndefInitializer, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c8b4a720)[ Core.MethodMatch(spec_types=Tuple{Type{Union{}}, UndefInitializer, Int64}, sparams=svec(), method=(::Type{Union{}})(Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{Memory{ForwardDiff.Dual{T, Float16, _A}}}, UndefInitializer, Int64} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A, sparams=svec(T<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A), Core.AddrSpace{Core}(0x00), :not_atomic), method=(::Type{GenericMemory{kind, T, addrspace}})(UndefInitializer, Int64) where {T, addrspace, kind}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000100, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.isnan), Tuple{Array{Float16, 1}}}}, typeof(Base.isnan), Tuple{Array{Float16, 1}}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bf665380)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.isnan), Tuple{Array{Float16, 1}}}}, typeof(Base.isnan), Tuple{Array{Float16, 1}}, Tuple{Base.OneTo{Int64}}}, sparams=svec(Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.isnan), Tuple{Array{Float16, 1}}), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args}})(Any, Any, Any) where {Style, Axes, F, Args}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b7, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{ADNLPModels.var"##hess_coord!#330", Any, typeof(NLPModels.hess_coord!), Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, Array{T, N} where N where T, AbstractArray{T, 1} 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=(1,), mem=Memory{Any}(1, 0x7f94cb8745e0)[Core.MethodMatch(spec_types=Tuple{ADNLPModels.var"##hess_coord!#330", Real, typeof(NLPModels.hess_coord!), Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, Array{T, 1} where T, AbstractArray{T, 1} where T, Base.SubArray{T, 1, P, I, L} where L where I where P where T}, sparams=svec(), method=var"#hess_coord!#330"(Real, typeof(NLPModels.hess_coord!), Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T), fully_covers=false)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ad, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setindex!), AbstractArray{ForwardDiff.Dual{T, ForwardDiff.Dual{T, V, N}, N}, N} where N where N where T where V where T, ForwardDiff.Dual{T, V, N} where N where V where T, Any}, limit=3), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Tuple{Array{Int64, 1}, Real}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c4cded60)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Tuple{Array{Int64, 1}, Real}, Int64}, sparams=svec(), method=getindex(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000669, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ForwardDiff.extract_jacobian_chunk!), Type{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)), Vararg{Any, 4}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fe1446c0)[Core.MethodMatch(spec_types=Tuple{typeof(ForwardDiff.extract_jacobian_chunk!), Type{T} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)), Vararg{Any, 4}}, sparams=svec(T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c))), method=extract_jacobian_chunk!(Type{T}, Any, Any, Any, Any) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto!), Any, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, _A, typeof(Base.identity), Tuple{Array{Float16, 1}}} where _A}, limit=1), nothing, Base.Compiler.MethodMatchKey(sig=Tuple{Type{ft} where ft<:Array{Float16, 1}, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c07be0a0)[ Core.MethodMatch(spec_types=Tuple{Type{Union{}}, Array{Float16, 1}}, sparams=svec(), method=(::Type{Union{}})(Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{Array{Float16, 1}}, Array{Float16, 1}}, sparams=svec(Float16, 1, Float16), method=(::Type{Array{T, N}})(AbstractArray{S, N}) where {T, N, S}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010df, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{var"#s175"} where var"#s175"<:(Array{ForwardDiff.Dual{T, V, _A}, 1} where _A where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A) where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c))), Array{ForwardDiff.Dual{T, V, _A}, 1} where _A where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A) where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c))}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94fcc825e0)[ Core.MethodMatch(spec_types=Tuple{Type{Union{}}, Array{ForwardDiff.Dual{T, V, _A}, 1} where _A where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A) where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c))}, sparams=svec(), method=(::Type{Union{}})(Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{Type{Array{ForwardDiff.Dual{T, V, _A}, 1}}, Array{ForwardDiff.Dual{T, V, _A}, 1}} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A) where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A) where _A, sparams=svec(T<:(ForwardDiff.Dual{T, V, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A) where _A), 1, S<:(ForwardDiff.Dual{T, V, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A) where _A)), method=(::Type{Array{T, N}})(AbstractArray{S, N}) where {T, N, S}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010df, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{Type{NamedTuple{(:obj_weight,), T} where T<:Tuple}, Tuple{Float16}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bfebc600)[Core.MethodMatch(spec_types=Tuple{Type{NamedTuple{(:obj_weight,), T} where T<:Tuple}, Tuple{Float16}}, sparams=svec((:obj_weight,)), method=(::Type{NamedTuple{names, T} where T<:Tuple})(Tuple) where {names}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000183, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ReverseDiff.jacobian!), ReverseDiff.JacobianTape{F, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}} where F<:(ReverseDiff.var"#hessian##0#hessian##1"{var"#s179", ReverseDiff.HessianConfig{ReverseDiff.GradientConfig{ReverseDiff.TrackedArray{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}}}, ReverseDiff.JacobianConfig{ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, Nothing}}} where var"#s179"<:Function), Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bf794780)[Core.MethodMatch(spec_types=Tuple{typeof(ReverseDiff.jacobian!), ReverseDiff.JacobianTape{F, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}} where F<:(ReverseDiff.var"#hessian##0#hessian##1"{var"#s179", ReverseDiff.HessianConfig{ReverseDiff.GradientConfig{ReverseDiff.TrackedArray{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}}}, ReverseDiff.JacobianConfig{ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, Nothing}}} where var"#s179"<:Function), Array{Float16, 1}}, sparams=svec(), method=jacobian!(Union{ReverseDiff.CompiledTape{T} where T<:(ReverseDiff.JacobianTape{F, I, O} where O where I where F), ReverseDiff.JacobianTape{F, I, O} where O where I where F}, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096a1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcast_unalias), Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Array{Float16, 1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bec42080)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcast_unalias), Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Array{Float16, 1}}, sparams=svec(), method=broadcast_unalias(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048c7, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(SparseMatricesCOO.columns), SparseMatricesCOO.SparseMatrixCOO{Float16, Ti} where Ti<:Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fd70ae60)[Core.MethodMatch(spec_types=Tuple{typeof(SparseMatricesCOO.columns), SparseMatricesCOO.SparseMatrixCOO{Float16, Ti} where Ti<:Integer}, sparams=svec(), method=columns(SparseMatricesCOO.SparseMatrixCOO{Tv, Ti} where Ti<:Integer where Tv), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ea, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{ForwardDiff.var"#hessian##0#hessian##1"{ADNLPModels.var"#64#65"{Array{Float16, 1}, _A}, ForwardDiff.HessianConfig{T, V, N, DG, DJ}} where DJ where DG where N where V where T where _A, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0c35ae0)[Core.MethodMatch(spec_types=Tuple{ForwardDiff.var"#hessian##0#hessian##1"{ADNLPModels.var"#64#65"{Array{Float16, 1}, _A}, ForwardDiff.HessianConfig{T, V, N, DG, DJ}} where DJ where DG where N where V where T where _A, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A}, sparams=svec(), method=(::ForwardDiff.var"#hessian##0#hessian##1"{f, cfg})(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setproperty!), SolverCore.GenericExecutionStats{T, V, V, Tsp} where Tsp where V where T, Symbol, Bool}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb874bc0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.setproperty!), SolverCore.GenericExecutionStats{T, V, V, Tsp} where Tsp where V where T, Symbol, Bool}, sparams=svec(), method=setproperty!(Any, Symbol, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000284, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.promote_type), Type{Tuple{Main.var"#F_linear#cannoles_tests##0", Array{Float64, 1}, Array{Float64, 1}}}, Type{Tuple{Main.var"#F_Rosen#cannoles_tests##1", Array{Float64, 1}, Array{Float64, 1}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ca89c520)[Core.MethodMatch(spec_types=Tuple{typeof(Base.promote_type), Type{Tuple{Main.var"#F_linear#cannoles_tests##0", Array{Float64, 1}, Array{Float64, 1}}}, Type{Tuple{Main.var"#F_Rosen#cannoles_tests##1", Array{Float64, 1}, Array{Float64, 1}}}}, sparams=svec(Tuple{Main.var"#F_linear#cannoles_tests##0", Array{Float64, 1}, Array{Float64, 1}}, Tuple{Main.var"#F_Rosen#cannoles_tests##1", Array{Float64, 1}, Array{Float64, 1}}), method=promote_type(Type{T}, Type{S}) where {T, S}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000005f9, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{Float16}, Float64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cae87ec0)[Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Float16}, Float64}, sparams=svec(Float16), method=convert(Type{T}, Number) where {T<:Number}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000a40, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.combine_styles), Array{Float16, 1}, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ce9c6200)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.combine_styles), Array{Float16, 1}, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where Args<:Tuple where F where Axes where var"#s677"}, sparams=svec(), method=combine_styles(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004832, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.:(+)), Any, Float16}, limit=3), nothing, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{LinearAlgebra.Adjoint{T, S} where S where T}, SparseMatricesCOO.SparseMatrixCOO{T, Int64} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94be5b4540)[Core.MethodMatch(spec_types=Tuple{Type{LinearAlgebra.Adjoint{T, S} where S where T}, SparseMatricesCOO.SparseMatrixCOO{T, Int64} where T}, sparams=svec(), method=(::Type{LinearAlgebra.Adjoint{T, S} where S where T})(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000007ac8, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Tuple{Tuple{Int64}, Tuple{Any}, Tuple{Int64}}, Int64}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94caba3a20)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getindex), Tuple{Tuple{Int64}, Tuple{Any}, Tuple{Int64}}, Int64}, sparams=svec(), method=getindex(Tuple, Int64), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000669, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.to_indices), Array{Float16, 1}, Tuple{Union{Integer, Base.IteratorsMD.CartesianIndex{N} where N}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(6, 0x7f94ccd04b60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.to_indices), Array{Float16, 1}, Tuple{Int64}}, sparams=svec(), method=to_indices(Any, Tuple{Vararg{Int64}}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.to_indices), Array{Float16, 1}, Tuple{Integer}}, sparams=svec(), method=to_indices(Any, Tuple{Vararg{Integer}}), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.to_indices), Array{Float16, 1}, Tuple{Union{Integer, Base.IteratorsMD.CartesianIndex{N} where N}}}, sparams=svec(), method=to_indices(Any, Tuple{Vararg{Union{Integer, Base.IteratorsMD.CartesianIndex{N} where N}}}), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000046ae, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.axes1), Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94bf455fa0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.axes1), Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}}, sparams=svec(), method=axes1(AbstractArray{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001237, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.jac_coord_residual!), NLPModels.AbstractNLPModel{T, S} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7f94ca6dfce0)[ Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_coord_residual!), Main.MGH01CON{T, S} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T}, sparams=svec(), method=jac_coord_residual!(Main.MGH01CON{T, S} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_coord_residual!), Main.MGH01_noFHess{T, S} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T}, sparams=svec(), method=jac_coord_residual!(Main.MGH01_noFHess{T, S} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_coord_residual!), ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T}, sparams=svec(), method=jac_coord_residual!(ADNLPModels.ADNLSModel{T, S, Si} where Si where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T), fully_covers=false), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009704, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.memoryref), Memory{ForwardDiff.Dual{T, V, _A}} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A) where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ff267ea0)[Core.MethodMatch(spec_types=Tuple{typeof(Core.memoryref), Memory{ForwardDiff.Dual{T, V, _A}} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A) where _A}, 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(Core._typeof_captured_variable), ADNLPModels.var"#F!#369"{var"#s179", var"#s179"} where var"#s179"<:Integer where var"#s179"<:Function}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cc1a5be0)[Core.MethodMatch(spec_types=Tuple{typeof(Core._typeof_captured_variable), ADNLPModels.var"#F!#369"{var"#s179", var"#s179"} where var"#s179"<:Integer where var"#s179"<:Function}, 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.convert), Type{var"#s175"} where var"#s175"<:Tuple, Tuple}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7f94ca62cfe0)[ 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"#s175"} where var"#s175"<:Tuple, Tuple}, sparams=svec(Vararg, var"#s175"<:Tuple), method=convert(Type{T}, Tuple{Vararg{Any, N}}) where {N, T<:Tuple}, fully_covers=true), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000377, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{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.isnan), Tuple{Array{Float16, 1}}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bf656420)[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.isnan), Tuple{Array{Float16, 1}}}}, sparams=svec(Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.isnan), Tuple{Array{Float16, 1}}), method=convert(Type{Base.Broadcast.Broadcasted{NewStyle, Axes, F, Args} where Args<:Tuple where F where Axes}, Base.Broadcast.Broadcasted{var"#s677", Axes, F, Args} where var"#s677") where {NewStyle, Axes, F, Args}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047d1, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(NLPModels.jac_coord!), Any, ADNLPModels.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}, Array{Float16, 1}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7f94c8198f60)[ Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_coord!), ADNLPModels.SparseADJacobian{Tag, R, T, C, S} where S where C where T where R where Tag, ADNLPModels.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}, Array{Float16, 1}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(), method=jac_coord!(ADNLPModels.SparseADJacobian{Tag, R, T, C, S} where S where C where T where R where Tag, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_coord!), ADNLPModels.ADBackend, ADNLPModels.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}, Array{Float16, 1}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(), method=jac_coord!(ADNLPModels.ADBackend, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(NLPModels.jac_coord!), NLPModels.AbstractNLPModel{T, S} where S where T, ADNLPModels.ADNLSModel{Float16, Array{Float16, 1}, Array{Int64, 1}}, Array{Float16, 1}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}}, sparams=svec(), method=jac_coord!(NLPModels.AbstractNLPModel{T, S} where S where T, Union{ADNLPModels.AbstractADNLPModel{T, S}, ADNLPModels.AbstractADNLSModel{T, S}} where S where T, AbstractArray{T, 1} where T, AbstractArray{T, 1} where T), fully_covers=false), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ad, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.IteratorSize}, ColorTypes.ComponentIterator{C} where C<:(Union{ColorTypes.AlphaColor{Cb, T, N} where N where T, ColorTypes.ColorAlpha{Cb, T, N} where N where T, Cb} where Cb<:Union{ColorTypes.HSI{T} where T<:AbstractFloat, ColorTypes.HSL{T} where T<:AbstractFloat, ColorTypes.HSV{T} where T<:AbstractFloat, ColorTypes.LCHab{T} where T<:AbstractFloat, ColorTypes.LCHuv{T} where T<:AbstractFloat, ColorTypes.Oklch{T} where T<:AbstractFloat})}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94bec77ba0)[Core.MethodMatch(spec_types=Tuple{Type{Base.IteratorSize}, ColorTypes.ComponentIterator{C} where C<:(Union{ColorTypes.AlphaColor{Cb, T, N} where N where T, ColorTypes.ColorAlpha{Cb, T, N} where N where T, Cb} where Cb<:Union{ColorTypes.HSI{T} where T<:AbstractFloat, ColorTypes.HSL{T} where T<:AbstractFloat, ColorTypes.HSV{T} where T<:AbstractFloat, ColorTypes.LCHab{T} where T<:AbstractFloat, ColorTypes.LCHuv{T} where T<:AbstractFloat, ColorTypes.Oklch{T} where T<:AbstractFloat})}, sparams=svec(), method=(::Type{Base.IteratorSize})(Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000445, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.kwcall), NamedTuple{(:x0,), Tuple{Array{Float64, 1}}}, Any, Int64, ADNLPModels.var"#49#50", Integer, ADNLPModels.var"#F!#369"{var"#s179", var"#s179"} where var"#s179"<:Integer where var"#s179"<:Function}, limit=3), nothing, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{CaNNOLeS.MA57Struct}, CaNNOLeS.LDLFactStruct{T, Ti} where Ti<:Integer where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(0,), mem=Memory{Any}(0, 0x7f9509e33d90)[]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000000, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(\)), Tuple{Bool, Array{Float16, 1}}}}, typeof(Base.:(\)), Tuple{Bool, Array{Float16, 1}}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c8888260)[Core.MethodMatch(spec_types=Tuple{Type{Base.Broadcast.Broadcasted{Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(\)), Tuple{Bool, Array{Float16, 1}}}}, typeof(Base.:(\)), Tuple{Bool, Array{Float16, 1}}, Tuple{Base.OneTo{Int64}}}, sparams=svec(Nothing, Tuple{Base.OneTo{Int64}}, typeof(Base.:(\)), Tuple{Bool, Array{Float16, 1}}), method=(::Type{Base.Broadcast.Broadcasted{Style, Axes, F, Args}})(Any, Any, Any) where {Style, Axes, F, Args}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000047b7, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.eachindex), AbstractArray{T, N} where N where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(6, 0x7f94cb5cf540)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), SparseArrays.ReadOnly{T, N, V} where V<:AbstractArray{T, N} where N where T}, sparams=svec(), method=eachindex(SparseArrays.ReadOnly{T, N, V} where V<:AbstractArray{T, N} where N where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), AbstractArray{T, 1} where T}, sparams=svec(), method=eachindex(AbstractArray{T, 1} where T), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.eachindex), AbstractArray{T, N} where N where T}, sparams=svec(), method=eachindex(AbstractArray{T, N} where N where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009678, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(ADNLPModels.jacobian), ADNLPModels.ADBackend, Any, AbstractArray{T, 1} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(3,), mem=Memory{Any}(4, 0x7f94c84925a0)[ Core.MethodMatch(spec_types=Tuple{typeof(ADNLPModels.jacobian), ADNLPModels.ForwardDiffADJacobian, Any, AbstractArray{T, 1} where T}, sparams=svec(), method=jacobian(ADNLPModels.ForwardDiffADJacobian, Any, Any), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(ADNLPModels.jacobian), ADNLPModels.ReverseDiffADJacobian, Any, AbstractArray{T, 1} where T}, sparams=svec(), method=jacobian(ADNLPModels.ReverseDiffADJacobian, Any, Any), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(ADNLPModels.jacobian), ADNLPModels.ADBackend, Any, AbstractArray{T, 1} where T}, sparams=svec(), method=jacobian(ADNLPModels.ADBackend, Any, Any), fully_covers=true), #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096ad, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{ForwardDiff.GradientConfig{T, V, N, D} where D where N where V where T}, ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)), ForwardDiff.Chunk{N} where N, ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ff029600)[Core.MethodMatch(spec_types=Tuple{Type{ForwardDiff.GradientConfig{T, V, N, D} where D where N where V where T}, ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c, Array{ForwardDiff.Dual{T, Float16, _A}, 1} where _A where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)), ForwardDiff.Chunk{N} where N, ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)}, sparams=svec(F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c), V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c)) where _A), N, T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##8"{Float16, ADNLPModels.var"#ℓ#437#get_lag##9"{c, F}, Base.SubArray{Float16, 1, Array{Float16, 1}, Tuple{Base.UnitRange{Int64}}, true}} where F where c))), method=(::Type{ForwardDiff.GradientConfig{T, V, N, D} where D where N where V where T})(F, AbstractArray{V, N} where N, ForwardDiff.Chunk{N}, T) where {F, V, N, T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009691, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.length), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0c88500)[Core.MethodMatch(spec_types=Tuple{typeof(Base.length), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A}, sparams=svec(T<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#64#65"{Array{Float16, 1}, _A} where _A)) where _A)), method=length(Array{T, 1}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000030c, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcastable), ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c9ede780)[Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcastable), ForwardDiff.var"#partials_wrap#extract_jacobian!##0"{T} where T}, sparams=svec(), method=broadcastable(Union{Base.Missing, Nothing, UndefInitializer, Base.AbstractPattern, AbstractString, Function, IO, Symbol, Base.Val{x} where x, Pair{A, B} where B where A, Ptr{T} where T, Base.IteratorsMD.CartesianIndex{N} where N, Base.Rounding.RoundingMode{T} where T}), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000048a0, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.setproperty!), CaNNOLeS.ParamCaNNOLeS{T} where T, Symbol, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94ca8c0140)[Core.MethodMatch(spec_types=Tuple{typeof(Base.setproperty!), CaNNOLeS.ParamCaNNOLeS{T} where T, Symbol, Any}, sparams=svec(), method=setproperty!(Any, Symbol, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000284, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.copyto_axcheck!), Array{T, 1} where T<:(ForwardDiff.Dual{T, V, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A) where _A), Array{ForwardDiff.Dual{T, V, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A) where _A}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fec6e140)[Core.MethodMatch(spec_types=Tuple{typeof(Base.copyto_axcheck!), Array{T, 1} where T<:(ForwardDiff.Dual{T, V, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A) where _A), Array{ForwardDiff.Dual{T, V, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:(ADNLPModels.var"#ℓ#get_lag##4"{Float16, ADNLPModels.var"#ℓ#435#get_lag##5"{F}} where F)) where _A) where _A}, sparams=svec(), method=copyto_axcheck!(Any, Any), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000012b7, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(CaNNOLeS.newton_system!), Array{Float64, 1}, Int64, Int64, Int64, Array{Float64, 1}, Array{Float64, 1}, CaNNOLeS.LDLFactStruct{T, Ti} where Ti<:Integer where T, Float64, CaNNOLeS.ParamCaNNOLeS{Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94cb65e380)[Core.MethodMatch(spec_types=Tuple{typeof(CaNNOLeS.newton_system!), Array{Float64, 1}, Int64, Int64, Int64, Array{Float64, 1}, Array{Float64, 1}, CaNNOLeS.LDLFactStruct{T, Ti} where Ti<:Integer where T, Float64, CaNNOLeS.ParamCaNNOLeS{Float64}}, sparams=svec(Float64), method=newton_system!(AbstractArray{T, 1}, Integer, Integer, Integer, AbstractArray{T, 1}, AbstractArray{T, 1}, CaNNOLeS.LinearSolverStruct, T, CaNNOLeS.ParamCaNNOLeS{T}) where {T}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000096eb, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(&)), Any, Any}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c3bd9ea0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(&)), Any, Any}, sparams=svec(typeof(Base.:(&))), method=broadcasted(F, Any, Any, Any...) where {F}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000004959, max_world=0xffffffffffffffff), ambig=false), Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.to_shape), Tuple{Union{Int64, Base.OneTo{T} where T<:Integer}, Int64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94bf201b60)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.to_shape), Tuple{Int64, Int64}}, sparams=svec(), method=to_shape(Tuple{Vararg{Int64, N}} where N), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.to_shape), Tuple{Union{Int64, Base.OneTo{T} where T<:Integer}, Int64}}, sparams=svec(), method=to_shape(Tuple{Vararg{Union{Integer, Base.AbstractUnitRange{T} where T}, N}} where N), fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000001296, max_world=0xffffffffffffffff), ambig=false), #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(StaticArrays.length_match_size), Type{StaticArraysCore.SArray{Tuple{2}, _A, N, L} where L where N} where _A, Tuple{Float64, Float64}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c4cd0260)[Core.MethodMatch(spec_types=Tuple{typeof(StaticArrays.length_match_size), Type{StaticArraysCore.SArray{Tuple{2}, _A, N, L} where L where N} where _A, Tuple{Float64, Float64}}, sparams=svec(SA<:(StaticArraysCore.SArray{Tuple{2}, _A, N, L} where L where N where _A)), method=length_match_size(Type{SA}, Any) where {SA<:(StaticArraysCore.StaticArray{S, T, N} where N where T where S<:Tuple)}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000009697, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.axes), LinearAlgebra.Adjoint{Float16, SparseMatricesCOO.SparseMatrixCOO{Float16, Ti}} where Ti<:Integer}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94cf9688e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.axes), LinearAlgebra.Adjoint{Float16, SparseMatricesCOO.SparseMatrixCOO{Float16, Ti}} where Ti<:Integer}, sparams=svec(), method=axes(Union{LinearAlgebra.Adjoint{T, M}, LinearAlgebra.Transpose{T, M}} where M<:(AbstractArray{T, 2} where T) where T), fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000007af7, 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!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{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, 0x7f94c17435a0)[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!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{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=0x0000000000000be5, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getindex), Array{ForwardDiff.Dual{T, Float16, _A}, 1} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A, Any}, limit=3), nothing, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.getproperty), SparseMatricesCOO.SparseMatrixCOO{T, Int64} where T, Symbol}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c0787820)[Core.MethodMatch(spec_types=Tuple{typeof(Base.getproperty), SparseMatricesCOO.SparseMatrixCOO{T, Int64} where T, Symbol}, sparams=svec(), method=getproperty(Any, Symbol), fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000283, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.reshape), Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Base.Val{1}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(4, 0x7f94c0296960)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.reshape), Base.SubArray{Float16, 1, Array{Float16, 1}, I, false} where I<:Tuple{Array{T, 1} where T<:Integer}, Base.Val{1}}, sparams=svec(Float16, 1), method=reshape(AbstractArray{T, N}, Base.Val{N}) where {T, N}, fully_covers=true), #, #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000003306, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:(Array{ForwardDiff.Dual{T, V, _A}, 1} where _A where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A) where T<:(ForwardDiff.Tag{F, Float16} where F<:Function)), Array{ForwardDiff.Dual{T, V, _A}, 1} where _A where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A) where T<:(ForwardDiff.Tag{F, Float16} where F<:Function)}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94c1267de0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, Array{ForwardDiff.Dual{T, V, _A}, 1} where _A where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A) where T<:(ForwardDiff.Tag{F, Float16} where F<:Function)}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{var"#s175"} where var"#s175"<:(Array{ForwardDiff.Dual{T, V, _A}, 1} where _A where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A) where T<:(ForwardDiff.Tag{F, Float16} where F<:Function)), Array{ForwardDiff.Dual{T, V, _A}, 1} where _A where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A) where T<:(ForwardDiff.Tag{F, Float16} where F<:Function)}, sparams=svec(var"#s175"<:(Array{ForwardDiff.Dual{T, V, _A}, 1} where _A where V<:(ForwardDiff.Dual{T, Float16, _A} where T<:(ForwardDiff.Tag{F, Float16} where F<:Function) where _A) where T<:(ForwardDiff.Tag{F, Float16} where F<:Function))), method=convert(Type{T}, AbstractArray{T, N} where N where T) where {T<:(Array{T, N} where N where T)}, fully_covers=true), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x00000000000010dd, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{NamedTuple{(:x0,), T} where T<:Tuple}, Tuple{Array{Float64, 1}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94fe0c0f80)[Core.MethodMatch(spec_types=Tuple{Type{NamedTuple{(:x0,), T} where T<:Tuple}, Tuple{Array{Float64, 1}}}, sparams=svec((:x0,)), method=(::Type{NamedTuple{names, T} where T<:Tuple})(Tuple) where {names}, fully_covers=true)]), valid_worlds=Base.Compiler.WorldRange(min_world=0x0000000000000183, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{typeof(Core.Typeof), Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{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, 0x7f94cf5be320)[Core.MethodMatch(spec_types=Tuple{typeof(Core.Typeof), Base.Fix{1, Type{Base.MappingRF{F, T} where T where F}, NLPModels.var"#jac_structure!##0#jac_structure!##1"{ADNLPModels.ADNLSModel{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.convert), Type{F} where F<:(ReverseDiff.var"#hessian##0#hessian##1"{var"#s179", ReverseDiff.HessianConfig{ReverseDiff.GradientConfig{ReverseDiff.TrackedArray{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}}}, ReverseDiff.JacobianConfig{ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, Nothing}}} where var"#s179"<:Function), ReverseDiff.var"#hessian##0#hessian##1"{var"#s179", ReverseDiff.HessianConfig{ReverseDiff.GradientConfig{ReverseDiff.TrackedArray{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}}}, ReverseDiff.JacobianConfig{ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, Nothing}}} where var"#s179"<:Function}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(2,), mem=Memory{Any}(4, 0x7f94bf7f57e0)[ Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{Union{}}, ReverseDiff.var"#hessian##0#hessian##1"{var"#s179", ReverseDiff.HessianConfig{ReverseDiff.GradientConfig{ReverseDiff.TrackedArray{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}}}, ReverseDiff.JacobianConfig{ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, Nothing}}} where var"#s179"<:Function}, sparams=svec(), method=convert(Type{Union{}}, Any...), fully_covers=false), Core.MethodMatch(spec_types=Tuple{typeof(Base.convert), Type{T}, ReverseDiff.var"#hessian##0#hessian##1"{var"#s179", ReverseDiff.HessianConfig{ReverseDiff.GradientConfig{ReverseDiff.TrackedArray{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}}}, ReverseDiff.JacobianConfig{ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, Nothing}}} where var"#s179"<:Function} where T<:(ReverseDiff.var"#hessian##0#hessian##1"{var"#s179", ReverseDiff.HessianConfig{ReverseDiff.GradientConfig{ReverseDiff.TrackedArray{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}, Array{ReverseDiff.TrackedReal{Float16, Float16, ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}}, 1}}}, ReverseDiff.JacobianConfig{ReverseDiff.TrackedArray{Float16, Float16, 1, Array{Float16, 1}, Array{Float16, 1}}, Nothing}}} where var"#s179"<:Function), sparams=svec(T), method=convert(Type{T}, T) where {T}, fully_covers=false), #, #]), valid_worlds=Base.Compiler.WorldRange(min_world=0x000000000000034c, max_world=0xffffffffffffffff), ambig=false), #, #, #, #, #, #, #, #, #, #, #, #, #, #, Base.Compiler.MethodMatchKey(sig=Tuple{Type{Base.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}, Base.SubArray{Float64, 1, Array{Float64, 1}, Tuple{Base.UnitRange{Int64}}, true}}, Tuple{Base.OneTo{Int64}}}, limit=3), Base.Compiler.MethodLookupResult(matches=Array{Any, 1}(dims=(1,), mem=Memory{Any}(1, 0x7f94c3d0ab40)[Core.MethodMatch(spec_types=Tuple{Type{ PkgEval terminated after 454.95s: test log exceeded the size limit