Package evaluation to test InfiniteExaModels on Julia 1.14.0-DEV.2086 (d19eac062f*) started at 2026-04-28T20:11:42.591


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

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

Set-up completed after 16.09s


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

Installing InfiniteExaModels...
   Resolving package versions...
    Updating `~/.julia/environments/v1.14/Project.toml`
  [ffdf776e] + InfiniteExaModels v0.1.2
    Updating `~/.julia/environments/v1.14/Manifest.toml`
  [66dad0bd] + AliasTables v1.1.3
  [523fee87] + CodecBzip2 v0.8.5
  [944b1d66] + CodecZlib v0.7.8
  [bbf7d656] + CommonSubexpressions v0.3.1
  [9a962f9c] + DataAPI v1.16.0
  [864edb3b] + DataStructures v0.19.4
  [163ba53b] + DiffResults v1.1.0
  [b552c78f] + DiffRules v1.15.1
  [31c24e10] + Distributions v0.25.125
  [ffbed154] + DocStringExtensions v0.9.5
  [1037b233] + ExaModels v0.9.7
  [e2ba6199] + ExprTools v0.1.10
  [9aa1b823] + FastClosures v0.3.2
  [442a2c76] + FastGaussQuadrature v1.1.0
  [1a297f60] + FillArrays v1.16.0
  [f6369f11] + ForwardDiff v1.3.3
  [34004b35] + HypergeometricFunctions v0.3.28
  [ffdf776e] + InfiniteExaModels v0.1.2
  [20393b10] + InfiniteOpt v0.6.1
  [92d709cd] + IrrationalConstants v0.2.6
  [692b3bcd] + JLLWrappers v1.7.1
  [682c06a0] + JSON v1.5.1
  [4076af6c] + JuMP v1.30.1
  [5c8ed15e] + LinearOperators v2.13.0
  [2ab3a3ac] + LogExpFunctions v0.3.29
  [1914dd2f] + MacroTools v0.5.16
  [b8f27783] + MathOptInterface v1.51.0
  [e1d29d7a] + Missings v1.2.0
  [d8a4904e] + MutableArithmetics v1.7.1
  [a4795742] + NLPModels v0.21.12
  [77ba4419] + NaNMath v1.1.3
  [bac558e1] + OrderedCollections v1.8.1
  [90014a1f] + PDMats v0.11.37
  [69de0a69] + Parsers v2.8.4
  [aea7be01] + PrecompileTools v1.3.3
  [21216c6a] + Preferences v1.5.2
  [43287f4e] + PtrArrays v1.4.0
  [1fd47b50] + QuadGK v2.11.3
  [189a3867] + Reexport v1.2.2
  [79098fc4] + Rmath v0.9.0
  [ff4d7338] + SolverCore v0.3.10
  [a2af1166] + SortingAlgorithms v1.2.2
  [276daf66] + SpecialFunctions v2.7.2
  [90137ffa] + StaticArrays v1.9.18
  [1e83bf80] + StaticArraysCore v1.4.4
  [10745b16] + Statistics v1.11.1
  [82ae8749] + StatsAPI v1.8.0
  [2913bbd2] + StatsBase v0.34.10
  [4c63d2b9] + StatsFuns v1.5.2
  [ec057cc2] + StructUtils v2.8.0
  [a759f4b9] + TimerOutputs v0.5.29
  [3bb67fe8] + TranscodingStreams v0.11.3
  [6e34b625] + Bzip2_jll v1.0.9+0
  [efe28fd5] + OpenSpecFun_jll v0.5.6+0
  [f50d1b31] + Rmath_jll v0.5.1+0
  [56f22d72] + Artifacts v1.11.0
  [2a0f44e3] + Base64 v1.11.0
  [ade2ca70] + Dates v1.11.0
  [b77e0a4c] + InteractiveUtils v1.11.0
  [ac6e5ff7] + JuliaSyntaxHighlighting v1.13.0
  [8f399da3] + Libdl v1.11.0
  [37e2e46d] + LinearAlgebra v1.13.0
  [56ddb016] + Logging v1.11.0
  [d6f4376e] + Markdown v1.11.0
  [de0858da] + Printf v1.11.0
  [9a3f8284] + Random v1.11.0
  [ea8e919c] + SHA v1.0.0
  [9e88b42a] + Serialization v1.11.0
  [2f01184e] + SparseArrays v1.13.0
  [f489334b] + StyledStrings v1.13.0
  [4607b0f0] + SuiteSparse
  [fa267f1f] + TOML v1.0.3
  [8dfed614] + Test v1.11.0
  [cf7118a7] + UUIDs v1.11.0
  [4ec0a83e] + Unicode v1.11.0
  [e66e0078] + CompilerSupportLibraries_jll v1.5.1+0
  [4536629a] + OpenBLAS_jll v0.3.32+0
  [05823500] + OpenLibm_jll v0.8.7+0
  [bea87d4a] + SuiteSparse_jll v7.10.1+0
  [83775a58] + Zlib_jll v1.3.2+0
  [8e850b90] + libblastrampoline_jll v5.15.0+0

Installation completed after 7.52s


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

Precompiling PkgEval dependencies...

Precompiling package dependencies...
Precompiling project...
  13.5 s  ✓ ExaModels → ExaModelsMOI
  14.9 s  ✓ ExaModels → ExaModelsJuMP
  30.4 s  ✓ InfiniteOpt
  27.8 s  ✓ ExaModels → ExaModelsMadNLP
  13.1 s  ✓ ExaModels → ExaModelsIpopt
  17.7 s  ✓ InfiniteExaModels
  33.2 s  ✓ InfiniteExaModels → InfiniteExaModelsMadNLP
  18.5 s  ✓ InfiniteExaModels → InfiniteExaModelsIpopt
  8 dependencies successfully precompiled in 172 seconds. 120 already precompiled.

Precompilation completed after 204.46s


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

     Testing InfiniteExaModels
      Status `/tmp/jl_TkUbHT/Project.toml`
  [1037b233] ExaModels v0.9.7
  [ffdf776e] InfiniteExaModels v0.1.2
  [20393b10] InfiniteOpt v0.6.1
  [b6b21f68] Ipopt v1.14.2
  [4076af6c] JuMP v1.30.1
  [2621e9c9] MadNLP v0.9.1
  [b8f27783] MathOptInterface v1.51.0
  [a4795742] NLPModels v0.21.12
  [f4238b75] NLPModelsIpopt v0.11.3
  [ff4d7338] SolverCore v0.3.10
  [fd094767] Suppressor v0.2.8
  [44cfe95a] Pkg v1.14.0
  [8dfed614] Test v1.11.0
      Status `/tmp/jl_TkUbHT/Manifest.toml`
  [14f7f29c] AMD v0.5.3
  [66dad0bd] AliasTables v1.1.3
  [523fee87] CodecBzip2 v0.8.5
  [944b1d66] CodecZlib v0.7.8
  [bbf7d656] CommonSubexpressions v0.3.1
  [9a962f9c] DataAPI v1.16.0
  [864edb3b] DataStructures v0.19.4
  [163ba53b] DiffResults v1.1.0
  [b552c78f] DiffRules v1.15.1
  [31c24e10] Distributions v0.25.125
  [ffbed154] DocStringExtensions v0.9.5
  [1037b233] ExaModels v0.9.7
  [e2ba6199] ExprTools v0.1.10
  [9aa1b823] FastClosures v0.3.2
  [442a2c76] FastGaussQuadrature v1.1.0
  [1a297f60] FillArrays v1.16.0
  [f6369f11] ForwardDiff v1.3.3
  [34004b35] HypergeometricFunctions v0.3.28
  [ffdf776e] InfiniteExaModels v0.1.2
  [20393b10] InfiniteOpt v0.6.1
  [b6b21f68] Ipopt v1.14.2
  [92d709cd] IrrationalConstants v0.2.6
  [692b3bcd] JLLWrappers v1.7.1
  [682c06a0] JSON v1.5.1
  [4076af6c] JuMP v1.30.1
  [40e66cde] LDLFactorizations v0.10.2
  [5c8ed15e] LinearOperators v2.13.0
  [2ab3a3ac] LogExpFunctions v0.3.29
  [1914dd2f] MacroTools v0.5.16
  [2621e9c9] MadNLP v0.9.1
  [b8f27783] MathOptInterface v1.51.0
  [e1d29d7a] Missings v1.2.0
  [d8a4904e] MutableArithmetics v1.7.1
  [a4795742] NLPModels v0.21.12
  [f4238b75] NLPModelsIpopt v0.11.3
  [e01155f1] NLPModelsModifiers v0.8.0
  [77ba4419] NaNMath v1.1.3
  [bac558e1] OrderedCollections v1.8.1
  [90014a1f] PDMats v0.11.37
  [69de0a69] Parsers v2.8.4
  [aea7be01] PrecompileTools v1.3.3
  [21216c6a] Preferences v1.5.2
  [43287f4e] PtrArrays v1.4.0
  [1fd47b50] QuadGK v2.11.3
  [189a3867] Reexport v1.2.2
  [79098fc4] Rmath v0.9.0
  [ff4d7338] SolverCore v0.3.10
  [a2af1166] SortingAlgorithms v1.2.2
  [276daf66] SpecialFunctions v2.7.2
  [90137ffa] StaticArrays v1.9.18
  [1e83bf80] StaticArraysCore v1.4.4
  [10745b16] Statistics v1.11.1
  [82ae8749] StatsAPI v1.8.0
  [2913bbd2] StatsBase v0.34.10
  [4c63d2b9] StatsFuns v1.5.2
  [ec057cc2] StructUtils v2.8.0
  [fd094767] Suppressor v0.2.8
  [a759f4b9] TimerOutputs v0.5.29
  [3bb67fe8] TranscodingStreams v0.11.3
  [ae81ac8f] ASL_jll v0.1.3+0
  [6e34b625] Bzip2_jll v1.0.9+0
  [e33a78d0] Hwloc_jll v2.13.0+1
  [9cc047cb] Ipopt_jll v300.1400.1901+0
  [94ce4f54] Libiconv_jll v1.18.0+0
  [d00139f3] METIS_jll v5.1.3+0
  [d7ed1dd3] MUMPS_seq_jll v500.800.200+0
  [656ef2d0] OpenBLAS32_jll v0.3.33+0
  [efe28fd5] OpenSpecFun_jll v0.5.6+0
  [f50d1b31] Rmath_jll v0.5.1+0
  [319450e9] SPRAL_jll v2025.9.18+0
⌅ [02c8fc9c] XML2_jll v2.13.9+0
  [a65dc6b1] Xorg_libpciaccess_jll v0.19.0+0
  [0dad84c5] ArgTools v1.1.2
  [56f22d72] Artifacts v1.11.0
  [2a0f44e3] Base64 v1.11.0
  [ade2ca70] Dates v1.11.0
  [f43a241f] Downloads v1.7.0
  [7b1f6079] FileWatching v1.11.0
  [b77e0a4c] InteractiveUtils v1.11.0
  [ac6e5ff7] JuliaSyntaxHighlighting v1.13.0
  [b27032c2] LibCURL v1.0.0
  [76f85450] LibGit2 v1.11.0
  [8f399da3] Libdl v1.11.0
  [37e2e46d] LinearAlgebra v1.13.0
  [56ddb016] Logging v1.11.0
  [d6f4376e] Markdown v1.11.0
  [ca575930] NetworkOptions v1.3.0
  [44cfe95a] Pkg v1.14.0
  [de0858da] Printf v1.11.0
  [9a3f8284] Random v1.11.0
  [ea8e919c] SHA v1.0.0
  [9e88b42a] Serialization v1.11.0
  [2f01184e] SparseArrays v1.13.0
  [f489334b] StyledStrings v1.13.0
  [4607b0f0] SuiteSparse
  [fa267f1f] TOML v1.0.3
  [a4e569a6] Tar v1.10.0
  [8dfed614] Test v1.11.0
  [cf7118a7] UUIDs v1.11.0
  [4ec0a83e] Unicode v1.11.0
  [e66e0078] CompilerSupportLibraries_jll v1.5.1+0
  [deac9b47] LibCURL_jll v8.19.0+0
  [e37daf67] LibGit2_jll v1.9.2+0
  [29816b5a] LibSSH2_jll v1.11.3+1
  [14a3606d] MozillaCACerts_jll v2026.3.19
  [4536629a] OpenBLAS_jll v0.3.32+0
  [05823500] OpenLibm_jll v0.8.7+0
  [458c3c95] OpenSSL_jll v3.5.6+0
  [efcefdf7] PCRE2_jll v10.47.0+0
  [bea87d4a] SuiteSparse_jll v7.10.1+0
  [83775a58] Zlib_jll v1.3.2+0
  [3161d3a3] Zstd_jll v1.5.7+1
  [8e850b90] libblastrampoline_jll v5.15.0+0
  [8e850ede] nghttp2_jll v1.69.0+0
  [3f19e933] p7zip_jll v17.8.0+0
        Info Packages marked with ⌅ have new versions available but compatibility constraints restrict them from upgrading.
     Testing Running tests...
************************************************
                BEGINNING TESTS                 
************************************************

Test Summary:         | Pass  Total     Time
Transcription Backend |   73     73  4m47.7s
288.239934 seconds (114.03 M allocations: 6.425 GiB, 2.14% gc time, 99.81% compilation time: <1% of which was recompilation)

******************************************************************************
This program contains Ipopt, a library for large-scale nonlinear optimization.
 Ipopt is released as open source code under the Eclipse Public License (EPL).
         For more information visit https://github.com/coin-or/Ipopt
******************************************************************************


Test Problem 1: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:22
  Test threw exception
  Expression: (optimize!(m)).status == :first_order
  TypeError: in typeassert, expected Nothing, got a value of type Tuple{Vector{Int32}, Vector{Int32}}
  Stacktrace:
    [1] _Eval_H_CB(n::Int32, x_ptr::Ptr{Float64}, ::Int32, obj_factor::Float64, m::Int32, lambda_ptr::Ptr{Float64}, ::Int32, nele_hess::Int32, iRow::Ptr{Int32}, jCol::Ptr{Int32}, values_ptr::Ptr{Float64}, user_data::Ptr{IpoptProblem})
      @ Ipopt ~/.julia/packages/Ipopt/dJbDQ/src/C_wrapper.jl:126
    [2] (::Ipopt.var"#IpoptSolve##0#IpoptSolve##1"{IpoptProblem, Base.RefValue{Float64}})()
      @ Ipopt ~/.julia/packages/Ipopt/dJbDQ/src/C_wrapper.jl:408 [inlined]
    [3] disable_sigint(f::Ipopt.var"#IpoptSolve##0#IpoptSolve##1"{IpoptProblem, Base.RefValue{Float64}})
      @ Base ./c.jl:167
    [4] in(key::Symbol, v::Base.KeySet{Symbol, Dict{Symbol, Int64}})
      @ Base ~/.julia/packages/Ipopt/dJbDQ/src/C_wrapper.jl:407 [inlined]
    [5] solve!(solver::IpoptSolver, nlp::ExaModel{Float64, Vector{Float64}, Nothing, ExaModels.Objective{ExaModels.Objective{ExaModels.ObjectiveNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), ExaModels.ParIndexed{ExaModels.ParSource, :c}, ExaModels.Node1{typeof(abs2), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{Int64}}}, Matrix{@NamedTuple{c::Float64, group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), Float64, ExaModels.Var{Int64}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{}}}, ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.ConstraintNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node1{typeof(sin), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, Float64}, ExaModels.Var{Int64}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{Int64}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.Var{Int64}}, ExaModels.Node2{typeof(*), Float64, ExaModels.ParIndexed{ExaModels.ParSource, :ip1}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Matrix{@NamedTuple{group_idx1::Int64, ip1::Float64, d_arg1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}, Int64}}, Int64}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx2::Int64, ip2::Float64, d_arg1::Float64}}, Int64}, Nothing}, stats::SolverCore.GenericExecutionStats{Float64, Vector{Float64}, Vector{Float64}, Any}; callback::NLPModelsIpopt.var"#15#16", kwargs::@Kwargs{print_level::Int64})
      @ NLPModelsIpopt ~/.julia/packages/NLPModelsIpopt/9iVBk/src/NLPModelsIpopt.jl:336
    [6] solve!
      @ ~/.julia/packages/NLPModelsIpopt/9iVBk/src/NLPModelsIpopt.jl:241 [inlined]
    [7] solve!(solver::IpoptSolver, model::ExaModel{Float64, Vector{Float64}, Nothing, ExaModels.Objective{ExaModels.Objective{ExaModels.ObjectiveNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), ExaModels.ParIndexed{ExaModels.ParSource, :c}, ExaModels.Node1{typeof(abs2), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{Int64}}}, Matrix{@NamedTuple{c::Float64, group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), Float64, ExaModels.Var{Int64}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{}}}, ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.ConstraintNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node1{typeof(sin), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, Float64}, ExaModels.Var{Int64}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{Int64}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.Var{Int64}}, ExaModels.Node2{typeof(*), Float64, ExaModels.ParIndexed{ExaModels.ParSource, :ip1}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Matrix{@NamedTuple{group_idx1::Int64, ip1::Float64, d_arg1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}, Int64}}, Int64}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx2::Int64, ip2::Float64, d_arg1::Float64}}, Int64}, Nothing}; kwargs::@Kwargs{print_level::Int64})
      @ SolverCoreNLPModelsExt ~/.julia/packages/SolverCore/UI1dA/ext/SolverCoreNLPModelsExt.jl:60 [inlined]
    [8] initial_solve(type::Type{IpoptSolver}, backend::ExaTranscriptionBackend{Nothing}, options::Dict{Symbol, Any})
      @ InfiniteExaModelsIpopt ~/.julia/packages/InfiniteExaModels/Mouyz/ext/InfiniteExaModelsIpopt.jl:49
    [9] ht_keyindex(h::Dict{Symbol, Any}, key::Symbol)
      @ Base ~/.julia/packages/InfiniteExaModels/Mouyz/src/infiniteopt_backend.jl:265 [inlined]
   [10] haskey(h::Dict{Symbol, Any}, key::Symbol)
      @ Base ./timing.jl:503 [inlined]
   [11] optimize!(backend::ExaTranscriptionBackend{Nothing})
      @ InfiniteExaModels ~/.julia/packages/InfiniteExaModels/Mouyz/src/infiniteopt_backend.jl:263
   [12] optimize!(model::InfiniteModel; ignore_optimize_hook::Bool, kwargs::@Kwargs{})
      @ InfiniteOpt ./Base_compiler.jl:0
   [13] optimize!(model::InfiniteModel)
      @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/backends.jl:445
   [14] top-level scope
      @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:4
   [15] macro expansion
      @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [16] macro expansion
      @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:22 [inlined]
   [17] macro expansion
      @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]

Test Problem 1: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:23
  Test threw exception
  Expression: isapprox(obj, objective_value(m), atol = tol)
  Unable to query `MathOptInterface.ObjectiveValue(1)` since up-to-date solution results are not available. This is likely because the transformation backend has not been built and optimized yet, or the model has been modified since the backend was optimized.
  Stacktrace:
   [1] error(s::String)
     @ Base ./error.jl:56
   [2] _check_result_is_current(model::InfiniteModel, func::MathOptInterface.ObjectiveValue)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:7 [inlined]
   [3] get_attribute(model::InfiniteModel, attr::MathOptInterface.ObjectiveValue)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:48
   [4] #objective_value#372
     @ ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:99 [inlined]
   [5] objective_value(model::InfiniteModel)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:98
   [6] top-level scope
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:4
   [7] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [8] macro expansion
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:23 [inlined]
   [9] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]

Test Problem 1: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:24
  Test threw exception
  Expression: all(isapprox.(yval, value(y), atol = tol))
  Unable to query `value` since up-to-date solution results are not available. This is likely because the transformation backend has not been built and optimized yet, or the model has been modified since the backend was optimized.
  Stacktrace:
   [1] error(s::String)
     @ Base ./error.jl:56
   [2] _check_result_is_current(model::InfiniteModel, func::typeof(value))
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:7 [inlined]
   [3] value(vref::GeneralVariableRef; kwargs::@Kwargs{})
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:312
   [4] value(vref::GeneralVariableRef)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:311
   [5] top-level scope
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:4
   [6] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [7] macro expansion
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:24 [inlined]
   [8] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]

Test Problem 1: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:25
  Test threw exception
  Expression: isapprox.(zval, value(z), atol = tol)
  Unable to query `value` since up-to-date solution results are not available. This is likely because the transformation backend has not been built and optimized yet, or the model has been modified since the backend was optimized.
  Stacktrace:
   [1] error(s::String)
     @ Base ./error.jl:56
   [2] _check_result_is_current(model::InfiniteModel, func::typeof(value))
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:7 [inlined]
   [3] value(vref::GeneralVariableRef; kwargs::@Kwargs{})
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:312
   [4] value(vref::GeneralVariableRef)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:311
   [5] top-level scope
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:4
   [6] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [7] macro expansion
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:25 [inlined]
   [8] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]

Test Problem 1: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:26
  Test threw exception
  Expression: isapprox(dyval, value(∂(y, t)), atol = tol)
  Unable to query `value` since up-to-date solution results are not available. This is likely because the transformation backend has not been built and optimized yet, or the model has been modified since the backend was optimized.
  Stacktrace:
   [1] error(s::String)
     @ Base ./error.jl:56
   [2] _check_result_is_current(model::InfiniteModel, func::typeof(value))
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:7 [inlined]
   [3] value(vref::GeneralVariableRef; kwargs::@Kwargs{})
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:312
   [4] value(vref::GeneralVariableRef)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:311
   [5] top-level scope
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:4
   [6] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [7] macro expansion
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:26 [inlined]
   [8] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]

Test Problem 1: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:40
  Test threw exception
  Expression: (optimize!(m)).status == :first_order
  TypeError: in typeassert, expected Nothing, got a value of type Tuple{Vector{Int32}, Vector{Int32}}
  Stacktrace:
    [1] _Eval_H_CB(n::Int32, x_ptr::Ptr{Float64}, ::Int32, obj_factor::Float64, m::Int32, lambda_ptr::Ptr{Float64}, ::Int32, nele_hess::Int32, iRow::Ptr{Int32}, jCol::Ptr{Int32}, values_ptr::Ptr{Float64}, user_data::Ptr{IpoptProblem})
      @ Ipopt ~/.julia/packages/Ipopt/dJbDQ/src/C_wrapper.jl:126
    [2] (::Ipopt.var"#IpoptSolve##0#IpoptSolve##1"{IpoptProblem, Base.RefValue{Float64}})()
      @ Ipopt ~/.julia/packages/Ipopt/dJbDQ/src/C_wrapper.jl:408 [inlined]
    [3] disable_sigint(f::Ipopt.var"#IpoptSolve##0#IpoptSolve##1"{IpoptProblem, Base.RefValue{Float64}})
      @ Base ./c.jl:167
    [4] in(key::Symbol, v::Base.KeySet{Symbol, Dict{Symbol, Int64}})
      @ Base ~/.julia/packages/Ipopt/dJbDQ/src/C_wrapper.jl:407 [inlined]
    [5] solve!(solver::IpoptSolver, nlp::ExaModel{Float64, Vector{Float64}, Nothing, ExaModels.Objective{ExaModels.Objective{ExaModels.ObjectiveNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), ExaModels.ParIndexed{ExaModels.ParSource, :c}, ExaModels.Node1{typeof(abs2), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{Int64}}}, Matrix{@NamedTuple{c::Float64, group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), Float64, ExaModels.Var{Int64}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{}}}, ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.ConstraintNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node1{typeof(sin), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, Float64}, ExaModels.Var{Int64}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{Int64}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.Var{Int64}}, ExaModels.Node2{typeof(*), Float64, ExaModels.ParIndexed{ExaModels.ParSource, :ip1}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), ExaModels.ParIndexed{ExaModels.ParSource, :d_arg3}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}, Int64}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.Node2{typeof(*), ExaModels.ParIndexed{ExaModels.ParSource, :d_arg2}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}, Int64}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.Compressor{NTuple{4, Int64}}, ExaModels.Compressor{Tuple{}}}, Matrix{@NamedTuple{group_idx1::Int64, ip1::Float64, d_arg1::Int64, d_arg2::Float64, d_arg3::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}, Int64}}, Int64}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx2::Int64, ip2::Float64, d_arg1::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :i1}, Int64}}, ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :i2}, Int64}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{i1::Int64, i2::Int64}}, Int64}, Nothing}, stats::SolverCore.GenericExecutionStats{Float64, Vector{Float64}, Vector{Float64}, Any}; callback::NLPModelsIpopt.var"#15#16", kwargs::@Kwargs{print_level::Int64})
      @ NLPModelsIpopt ~/.julia/packages/NLPModelsIpopt/9iVBk/src/NLPModelsIpopt.jl:336
    [6] solve!
      @ ~/.julia/packages/NLPModelsIpopt/9iVBk/src/NLPModelsIpopt.jl:241 [inlined]
    [7] solve!(solver::IpoptSolver, model::ExaModel{Float64, Vector{Float64}, Nothing, ExaModels.Objective{ExaModels.Objective{ExaModels.ObjectiveNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), ExaModels.ParIndexed{ExaModels.ParSource, :c}, ExaModels.Node1{typeof(abs2), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{Int64}}}, Matrix{@NamedTuple{c::Float64, group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), Float64, ExaModels.Var{Int64}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{}}}, ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.ConstraintNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node1{typeof(sin), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, Float64}, ExaModels.Var{Int64}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{Int64}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.Var{Int64}}, ExaModels.Node2{typeof(*), Float64, ExaModels.ParIndexed{ExaModels.ParSource, :ip1}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), ExaModels.ParIndexed{ExaModels.ParSource, :d_arg3}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}, Int64}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.Node2{typeof(*), ExaModels.ParIndexed{ExaModels.ParSource, :d_arg2}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}, Int64}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.Compressor{NTuple{4, Int64}}, ExaModels.Compressor{Tuple{}}}, Matrix{@NamedTuple{group_idx1::Int64, ip1::Float64, d_arg1::Int64, d_arg2::Float64, d_arg3::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}, Int64}}, Int64}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx2::Int64, ip2::Float64, d_arg1::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :i1}, Int64}}, ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :i2}, Int64}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{i1::Int64, i2::Int64}}, Int64}, Nothing}; kwargs::@Kwargs{print_level::Int64})
      @ SolverCoreNLPModelsExt ~/.julia/packages/SolverCore/UI1dA/ext/SolverCoreNLPModelsExt.jl:60 [inlined]
    [8] initial_solve(type::Type{IpoptSolver}, backend::ExaTranscriptionBackend{Nothing}, options::Dict{Symbol, Any})
      @ InfiniteExaModelsIpopt ~/.julia/packages/InfiniteExaModels/Mouyz/ext/InfiniteExaModelsIpopt.jl:49
    [9] ht_keyindex(h::Dict{Symbol, Any}, key::Symbol)
      @ Base ~/.julia/packages/InfiniteExaModels/Mouyz/src/infiniteopt_backend.jl:265 [inlined]
   [10] haskey(h::Dict{Symbol, Any}, key::Symbol)
      @ Base ./timing.jl:503 [inlined]
   [11] optimize!(backend::ExaTranscriptionBackend{Nothing})
      @ InfiniteExaModels ~/.julia/packages/InfiniteExaModels/Mouyz/src/infiniteopt_backend.jl:263
   [12] optimize!(model::InfiniteModel; ignore_optimize_hook::Bool, kwargs::@Kwargs{})
      @ InfiniteOpt ./Base_compiler.jl:0
   [13] optimize!(model::InfiniteModel)
      @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/backends.jl:445
   [14] top-level scope
      @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:4
   [15] macro expansion
      @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [16] macro expansion
      @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:40 [inlined]
   [17] macro expansion
      @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]

Test Problem 1: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:41
  Test threw exception
  Expression: isapprox(obj, objective_value(m), atol = tol)
  Unable to query `MathOptInterface.ObjectiveValue(1)` since up-to-date solution results are not available. This is likely because the transformation backend has not been built and optimized yet, or the model has been modified since the backend was optimized.
  Stacktrace:
   [1] error(s::String)
     @ Base ./error.jl:56
   [2] _check_result_is_current(model::InfiniteModel, func::MathOptInterface.ObjectiveValue)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:7 [inlined]
   [3] get_attribute(model::InfiniteModel, attr::MathOptInterface.ObjectiveValue)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:48
   [4] #objective_value#372
     @ ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:99 [inlined]
   [5] objective_value(model::InfiniteModel)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:98
   [6] top-level scope
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:4
   [7] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [8] macro expansion
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:41 [inlined]
   [9] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]

Test Problem 1: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:42
  Test threw exception
  Expression: all(isapprox.(yval, value(y), atol = tol))
  Unable to query `value` since up-to-date solution results are not available. This is likely because the transformation backend has not been built and optimized yet, or the model has been modified since the backend was optimized.
  Stacktrace:
   [1] error(s::String)
     @ Base ./error.jl:56
   [2] _check_result_is_current(model::InfiniteModel, func::typeof(value))
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:7 [inlined]
   [3] value(vref::GeneralVariableRef; kwargs::@Kwargs{})
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:312
   [4] value(vref::GeneralVariableRef)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:311
   [5] top-level scope
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:4
   [6] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [7] macro expansion
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:42 [inlined]
   [8] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]

Test Problem 1: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:43
  Test threw exception
  Expression: isapprox.(zval, value(z), atol = tol)
  Unable to query `value` since up-to-date solution results are not available. This is likely because the transformation backend has not been built and optimized yet, or the model has been modified since the backend was optimized.
  Stacktrace:
   [1] error(s::String)
     @ Base ./error.jl:56
   [2] _check_result_is_current(model::InfiniteModel, func::typeof(value))
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:7 [inlined]
   [3] value(vref::GeneralVariableRef; kwargs::@Kwargs{})
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:312
   [4] value(vref::GeneralVariableRef)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:311
   [5] top-level scope
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:4
   [6] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [7] macro expansion
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:43 [inlined]
   [8] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]

Test Problem 1: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:44
  Test threw exception
  Expression: isapprox(dyval, value(∂(y, t)), atol = tol)
  Unable to query `value` since up-to-date solution results are not available. This is likely because the transformation backend has not been built and optimized yet, or the model has been modified since the backend was optimized.
  Stacktrace:
   [1] error(s::String)
     @ Base ./error.jl:56
   [2] _check_result_is_current(model::InfiniteModel, func::typeof(value))
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:7 [inlined]
   [3] value(vref::GeneralVariableRef; kwargs::@Kwargs{})
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:312
   [4] value(vref::GeneralVariableRef)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:311
   [5] top-level scope
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:4
   [6] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [7] macro expansion
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:44 [inlined]
   [8] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]

Test Problem 2: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:66
  Test threw exception
  Expression: (optimize!(m)).status == :first_order
  TypeError: in typeassert, expected Nothing, got a value of type Tuple{Vector{Int32}, Vector{Int32}}
  Stacktrace:
    [1] _Eval_H_CB(n::Int32, x_ptr::Ptr{Float64}, ::Int32, obj_factor::Float64, m::Int32, lambda_ptr::Ptr{Float64}, ::Int32, nele_hess::Int32, iRow::Ptr{Int32}, jCol::Ptr{Int32}, values_ptr::Ptr{Float64}, user_data::Ptr{IpoptProblem})
      @ Ipopt ~/.julia/packages/Ipopt/dJbDQ/src/C_wrapper.jl:126
    [2] (::Ipopt.var"#IpoptSolve##0#IpoptSolve##1"{IpoptProblem, Base.RefValue{Float64}})()
      @ Ipopt ~/.julia/packages/Ipopt/dJbDQ/src/C_wrapper.jl:408 [inlined]
    [3] disable_sigint(f::Ipopt.var"#IpoptSolve##0#IpoptSolve##1"{IpoptProblem, Base.RefValue{Float64}})
      @ Base ./c.jl:167
    [4] in(key::Symbol, v::Base.KeySet{Symbol, Dict{Symbol, Int64}})
      @ Base ~/.julia/packages/Ipopt/dJbDQ/src/C_wrapper.jl:407 [inlined]
    [5] solve!(solver::IpoptSolver, nlp::ExaModel{Float64, Vector{Float64}, Nothing, ExaModels.Objective{ExaModels.Objective{ExaModels.ObjectiveNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), ExaModels.ParIndexed{ExaModels.ParSource, :c}, ExaModels.Node2{typeof(+), ExaModels.Node1{typeof(abs2), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.Node2{typeof(*), Float64, ExaModels.Var{Int64}}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{Int64}}}, Matrix{@NamedTuple{c::Float64, group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), Float64, ExaModels.Var{Int64}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{}}}, ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.ConstraintNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node1{typeof(sin), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, Float64}, ExaModels.Var{Int64}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{Int64}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.Var{Int64}}, ExaModels.Node2{typeof(*), Float64, ExaModels.ParIndexed{ExaModels.ParSource, :ip1}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Matrix{@NamedTuple{group_idx1::Int64, ip1::Float64, d_arg1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}, Int64}}, Int64}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx2::Int64, ip2::Float64, d_arg1::Float64}}, Int64}, Nothing}, stats::SolverCore.GenericExecutionStats{Float64, Vector{Float64}, Vector{Float64}, Any}; callback::NLPModelsIpopt.var"#15#16", kwargs::@Kwargs{print_level::Int64})
      @ NLPModelsIpopt ~/.julia/packages/NLPModelsIpopt/9iVBk/src/NLPModelsIpopt.jl:336
    [6] solve!
      @ ~/.julia/packages/NLPModelsIpopt/9iVBk/src/NLPModelsIpopt.jl:241 [inlined]
    [7] solve!(solver::IpoptSolver, model::ExaModel{Float64, Vector{Float64}, Nothing, ExaModels.Objective{ExaModels.Objective{ExaModels.ObjectiveNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), ExaModels.ParIndexed{ExaModels.ParSource, :c}, ExaModels.Node2{typeof(+), ExaModels.Node1{typeof(abs2), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.Node2{typeof(*), Float64, ExaModels.Var{Int64}}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{Int64}}}, Matrix{@NamedTuple{c::Float64, group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), Float64, ExaModels.Var{Int64}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{}}}, ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.ConstraintNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node1{typeof(sin), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, Float64}, ExaModels.Var{Int64}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{Int64}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.Var{Int64}}, ExaModels.Node2{typeof(*), Float64, ExaModels.ParIndexed{ExaModels.ParSource, :ip1}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Matrix{@NamedTuple{group_idx1::Int64, ip1::Float64, d_arg1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}, Int64}}, Int64}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx2::Int64, ip2::Float64, d_arg1::Float64}}, Int64}, Nothing}; kwargs::@Kwargs{print_level::Int64})
      @ SolverCoreNLPModelsExt ~/.julia/packages/SolverCore/UI1dA/ext/SolverCoreNLPModelsExt.jl:60 [inlined]
    [8] initial_solve(type::Type{IpoptSolver}, backend::ExaTranscriptionBackend{Nothing}, options::Dict{Symbol, Any})
      @ InfiniteExaModelsIpopt ~/.julia/packages/InfiniteExaModels/Mouyz/ext/InfiniteExaModelsIpopt.jl:49
    [9] ht_keyindex(h::Dict{Symbol, Any}, key::Symbol)
      @ Base ~/.julia/packages/InfiniteExaModels/Mouyz/src/infiniteopt_backend.jl:265 [inlined]
   [10] haskey(h::Dict{Symbol, Any}, key::Symbol)
      @ Base ./timing.jl:503 [inlined]
   [11] optimize!(backend::ExaTranscriptionBackend{Nothing})
      @ InfiniteExaModels ~/.julia/packages/InfiniteExaModels/Mouyz/src/infiniteopt_backend.jl:263
   [12] optimize!(model::InfiniteModel; ignore_optimize_hook::Bool, kwargs::@Kwargs{})
      @ InfiniteOpt ./Base_compiler.jl:0
   [13] optimize!(model::InfiniteModel)
      @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/backends.jl:445
   [14] macro expansion
      @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]
   [15] macro expansion
      @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:66 [inlined]
   [16] macro expansion
      @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [17] top-level scope
      @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:49

Test Problem 2: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:67
  Test threw exception
  Expression: isapprox(obj, objective_value(m), atol = tol)
  Unable to query `MathOptInterface.ObjectiveValue(1)` since up-to-date solution results are not available. This is likely because the transformation backend has not been built and optimized yet, or the model has been modified since the backend was optimized.
  Stacktrace:
   [1] error(s::String)
     @ Base ./error.jl:56
   [2] _check_result_is_current(model::InfiniteModel, func::MathOptInterface.ObjectiveValue)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:7 [inlined]
   [3] get_attribute(model::InfiniteModel, attr::MathOptInterface.ObjectiveValue)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:48
   [4] #objective_value#372
     @ ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:99 [inlined]
   [5] objective_value(model::InfiniteModel)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:98
   [6] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]
   [7] macro expansion
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:67 [inlined]
   [8] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [9] top-level scope
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:49

Test Problem 2: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:68
  Test threw exception
  Expression: all(isapprox.(yval, value(y), atol = tol))
  Unable to query `value` since up-to-date solution results are not available. This is likely because the transformation backend has not been built and optimized yet, or the model has been modified since the backend was optimized.
  Stacktrace:
   [1] error(s::String)
     @ Base ./error.jl:56
   [2] _check_result_is_current(model::InfiniteModel, func::typeof(value))
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:7 [inlined]
   [3] value(vref::GeneralVariableRef; kwargs::@Kwargs{})
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:312
   [4] value(vref::GeneralVariableRef)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:311
   [5] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]
   [6] macro expansion
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:68 [inlined]
   [7] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [8] top-level scope
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:49

Test Problem 2: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:69
  Test threw exception
  Expression: isapprox.(zval, value(z), atol = tol)
  Unable to query `value` since up-to-date solution results are not available. This is likely because the transformation backend has not been built and optimized yet, or the model has been modified since the backend was optimized.
  Stacktrace:
   [1] error(s::String)
     @ Base ./error.jl:56
   [2] _check_result_is_current(model::InfiniteModel, func::typeof(value))
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:7 [inlined]
   [3] value(vref::GeneralVariableRef; kwargs::@Kwargs{})
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:312
   [4] value(vref::GeneralVariableRef)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:311
   [5] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]
   [6] macro expansion
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:69 [inlined]
   [7] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [8] top-level scope
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:49

Test Problem 2: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:88
  Test threw exception
  Expression: (optimize!(m)).status == :first_order
  TypeError: in typeassert, expected Nothing, got a value of type Tuple{Vector{Int32}, Vector{Int32}}
  Stacktrace:
    [1] _Eval_H_CB(n::Int32, x_ptr::Ptr{Float64}, ::Int32, obj_factor::Float64, m::Int32, lambda_ptr::Ptr{Float64}, ::Int32, nele_hess::Int32, iRow::Ptr{Int32}, jCol::Ptr{Int32}, values_ptr::Ptr{Float64}, user_data::Ptr{IpoptProblem})
      @ Ipopt ~/.julia/packages/Ipopt/dJbDQ/src/C_wrapper.jl:126
    [2] (::Ipopt.var"#IpoptSolve##0#IpoptSolve##1"{IpoptProblem, Base.RefValue{Float64}})()
      @ Ipopt ~/.julia/packages/Ipopt/dJbDQ/src/C_wrapper.jl:408 [inlined]
    [3] disable_sigint(f::Ipopt.var"#IpoptSolve##0#IpoptSolve##1"{IpoptProblem, Base.RefValue{Float64}})
      @ Base ./c.jl:167
    [4] in(key::Symbol, v::Base.KeySet{Symbol, Dict{Symbol, Int64}})
      @ Base ~/.julia/packages/Ipopt/dJbDQ/src/C_wrapper.jl:407 [inlined]
    [5] solve!(solver::IpoptSolver, nlp::ExaModel{Float64, Vector{Float64}, Nothing, ExaModels.Objective{ExaModels.Objective{ExaModels.ObjectiveNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), ExaModels.ParIndexed{ExaModels.ParSource, :c}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Float64, ExaModels.Node1{typeof(abs2), ExaModels.Var{Int64}}}, ExaModels.Node1{typeof(abs2), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{Int64, Int64}}}, Matrix{@NamedTuple{c::Float64, group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), Float64, ExaModels.Var{Int64}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{}}}, ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.ConstraintNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node1{typeof(sin), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, Float64}, ExaModels.Var{Int64}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{Int64}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.Var{Int64}}, ExaModels.Node2{typeof(*), Float64, ExaModels.ParIndexed{ExaModels.ParSource, :ip1}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Matrix{@NamedTuple{group_idx1::Int64, ip1::Float64, d_arg1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}, Int64}}, Int64}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx2::Int64, ip2::Float64, d_arg1::Float64}}, Int64}, Nothing}, stats::SolverCore.GenericExecutionStats{Float64, Vector{Float64}, Vector{Float64}, Any}; callback::NLPModelsIpopt.var"#15#16", kwargs::@Kwargs{print_level::Int64})
      @ NLPModelsIpopt ~/.julia/packages/NLPModelsIpopt/9iVBk/src/NLPModelsIpopt.jl:336
    [6] solve!
      @ ~/.julia/packages/NLPModelsIpopt/9iVBk/src/NLPModelsIpopt.jl:241 [inlined]
    [7] solve!(solver::IpoptSolver, model::ExaModel{Float64, Vector{Float64}, Nothing, ExaModels.Objective{ExaModels.Objective{ExaModels.ObjectiveNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), ExaModels.ParIndexed{ExaModels.ParSource, :c}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Float64, ExaModels.Node1{typeof(abs2), ExaModels.Var{Int64}}}, ExaModels.Node1{typeof(abs2), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{Int64, Int64}}}, Matrix{@NamedTuple{c::Float64, group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), Float64, ExaModels.Var{Int64}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{}}}, ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.ConstraintNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node1{typeof(sin), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, Float64}, ExaModels.Var{Int64}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{Int64}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.Var{Int64}}, ExaModels.Node2{typeof(*), Float64, ExaModels.ParIndexed{ExaModels.ParSource, :ip1}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Matrix{@NamedTuple{group_idx1::Int64, ip1::Float64, d_arg1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}, Int64}}, Int64}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx2::Int64, ip2::Float64, d_arg1::Float64}}, Int64}, Nothing}; kwargs::@Kwargs{print_level::Int64})
      @ SolverCoreNLPModelsExt ~/.julia/packages/SolverCore/UI1dA/ext/SolverCoreNLPModelsExt.jl:60 [inlined]
    [8] initial_solve(type::Type{IpoptSolver}, backend::ExaTranscriptionBackend{Nothing}, options::Dict{Symbol, Any})
      @ InfiniteExaModelsIpopt ~/.julia/packages/InfiniteExaModels/Mouyz/ext/InfiniteExaModelsIpopt.jl:49
    [9] ht_keyindex(h::Dict{Symbol, Any}, key::Symbol)
      @ Base ~/.julia/packages/InfiniteExaModels/Mouyz/src/infiniteopt_backend.jl:265 [inlined]
   [10] haskey(h::Dict{Symbol, Any}, key::Symbol)
      @ Base ./timing.jl:503 [inlined]
   [11] optimize!(backend::ExaTranscriptionBackend{Nothing})
      @ InfiniteExaModels ~/.julia/packages/InfiniteExaModels/Mouyz/src/infiniteopt_backend.jl:263
   [12] optimize!(model::InfiniteModel; ignore_optimize_hook::Bool, kwargs::@Kwargs{})
      @ InfiniteOpt ./Base_compiler.jl:0
   [13] optimize!(model::InfiniteModel)
      @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/backends.jl:445
   [14] macro expansion
      @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]
   [15] macro expansion
      @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:88 [inlined]
   [16] macro expansion
      @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [17] top-level scope
      @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:49

Test Problem 2: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:89
  Test threw exception
  Expression: isapprox(obj, objective_value(m), atol = tol)
  Unable to query `MathOptInterface.ObjectiveValue(1)` since up-to-date solution results are not available. This is likely because the transformation backend has not been built and optimized yet, or the model has been modified since the backend was optimized.
  Stacktrace:
   [1] error(s::String)
     @ Base ./error.jl:56
   [2] _check_result_is_current(model::InfiniteModel, func::MathOptInterface.ObjectiveValue)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:7 [inlined]
   [3] get_attribute(model::InfiniteModel, attr::MathOptInterface.ObjectiveValue)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:48
   [4] #objective_value#372
     @ ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:99 [inlined]
   [5] objective_value(model::InfiniteModel)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:98
   [6] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]
   [7] macro expansion
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:89 [inlined]
   [8] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [9] top-level scope
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:49

Test Problem 2: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:90
  Test threw exception
  Expression: all(isapprox.(yval, value(y), atol = tol))
  Unable to query `value` since up-to-date solution results are not available. This is likely because the transformation backend has not been built and optimized yet, or the model has been modified since the backend was optimized.
  Stacktrace:
   [1] error(s::String)
     @ Base ./error.jl:56
   [2] _check_result_is_current(model::InfiniteModel, func::typeof(value))
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:7 [inlined]
   [3] value(vref::GeneralVariableRef; kwargs::@Kwargs{})
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:312
   [4] value(vref::GeneralVariableRef)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:311
   [5] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]
   [6] macro expansion
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:90 [inlined]
   [7] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [8] top-level scope
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:49

Test Problem 2: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:91
  Test threw exception
  Expression: isapprox.(zval, value(z), atol = tol)
  Unable to query `value` since up-to-date solution results are not available. This is likely because the transformation backend has not been built and optimized yet, or the model has been modified since the backend was optimized.
  Stacktrace:
   [1] error(s::String)
     @ Base ./error.jl:56
   [2] _check_result_is_current(model::InfiniteModel, func::typeof(value))
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:7 [inlined]
   [3] value(vref::GeneralVariableRef; kwargs::@Kwargs{})
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:312
   [4] value(vref::GeneralVariableRef)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:311
   [5] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]
   [6] macro expansion
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:91 [inlined]
   [7] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [8] top-level scope
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:49

Test Problem 2: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:88
  Test threw exception
  Expression: (optimize!(m)).status == :first_order
  TypeError: in typeassert, expected Nothing, got a value of type Tuple{Vector{Int32}, Vector{Int32}}
  Stacktrace:
    [1] _Eval_H_CB(n::Int32, x_ptr::Ptr{Float64}, ::Int32, obj_factor::Float64, m::Int32, lambda_ptr::Ptr{Float64}, ::Int32, nele_hess::Int32, iRow::Ptr{Int32}, jCol::Ptr{Int32}, values_ptr::Ptr{Float64}, user_data::Ptr{IpoptProblem})
      @ Ipopt ~/.julia/packages/Ipopt/dJbDQ/src/C_wrapper.jl:126
    [2] (::Ipopt.var"#IpoptSolve##0#IpoptSolve##1"{IpoptProblem, Base.RefValue{Float64}})()
      @ Ipopt ~/.julia/packages/Ipopt/dJbDQ/src/C_wrapper.jl:408 [inlined]
    [3] disable_sigint(f::Ipopt.var"#IpoptSolve##0#IpoptSolve##1"{IpoptProblem, Base.RefValue{Float64}})
      @ Base ./c.jl:167
    [4] in(key::Symbol, v::Base.KeySet{Symbol, Dict{Symbol, Int64}})
      @ Base ~/.julia/packages/Ipopt/dJbDQ/src/C_wrapper.jl:407 [inlined]
    [5] solve!(solver::IpoptSolver, nlp::ExaModel{Float64, Vector{Float64}, Nothing, ExaModels.Objective{ExaModels.ObjectiveNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), ExaModels.ParIndexed{ExaModels.ParSource, :c}, ExaModels.Node2{typeof(+), ExaModels.Node1{typeof(abs2), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.Node1{typeof(sin), ExaModels.Node1{typeof(abs2), ExaModels.Var{Int64}}}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{Int64, Int64}}}, Matrix{@NamedTuple{c::Float64, group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}}, ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.ConstraintNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node1{typeof(sin), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, Float64}, ExaModels.Var{Int64}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{Int64}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.Var{Int64}}, ExaModels.Node2{typeof(*), Float64, ExaModels.ParIndexed{ExaModels.ParSource, :ip1}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Matrix{@NamedTuple{group_idx1::Int64, ip1::Float64, d_arg1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}, Int64}}, Int64}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx2::Int64, ip2::Float64, d_arg1::Float64}}, Int64}, Nothing}, stats::SolverCore.GenericExecutionStats{Float64, Vector{Float64}, Vector{Float64}, Any}; callback::NLPModelsIpopt.var"#15#16", kwargs::@Kwargs{print_level::Int64})
      @ NLPModelsIpopt ~/.julia/packages/NLPModelsIpopt/9iVBk/src/NLPModelsIpopt.jl:336
    [6] solve!
      @ ~/.julia/packages/NLPModelsIpopt/9iVBk/src/NLPModelsIpopt.jl:241 [inlined]
    [7] solve!(solver::IpoptSolver, model::ExaModel{Float64, Vector{Float64}, Nothing, ExaModels.Objective{ExaModels.ObjectiveNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), ExaModels.ParIndexed{ExaModels.ParSource, :c}, ExaModels.Node2{typeof(+), ExaModels.Node1{typeof(abs2), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.Node1{typeof(sin), ExaModels.Node1{typeof(abs2), ExaModels.Var{Int64}}}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{Int64, Int64}}}, Matrix{@NamedTuple{c::Float64, group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}}, ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.ConstraintNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node1{typeof(sin), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, Float64}, ExaModels.Var{Int64}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{Int64}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.Var{Int64}}, ExaModels.Node2{typeof(*), Float64, ExaModels.ParIndexed{ExaModels.ParSource, :ip1}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Matrix{@NamedTuple{group_idx1::Int64, ip1::Float64, d_arg1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}, Int64}}, Int64}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx2::Int64, ip2::Float64, d_arg1::Float64}}, Int64}, Nothing}; kwargs::@Kwargs{print_level::Int64})
      @ SolverCoreNLPModelsExt ~/.julia/packages/SolverCore/UI1dA/ext/SolverCoreNLPModelsExt.jl:60 [inlined]
    [8] initial_solve(type::Type{IpoptSolver}, backend::ExaTranscriptionBackend{Nothing}, options::Dict{Symbol, Any})
      @ InfiniteExaModelsIpopt ~/.julia/packages/InfiniteExaModels/Mouyz/ext/InfiniteExaModelsIpopt.jl:49
    [9] ht_keyindex(h::Dict{Symbol, Any}, key::Symbol)
      @ Base ~/.julia/packages/InfiniteExaModels/Mouyz/src/infiniteopt_backend.jl:265 [inlined]
   [10] haskey(h::Dict{Symbol, Any}, key::Symbol)
      @ Base ./timing.jl:503 [inlined]
   [11] optimize!(backend::ExaTranscriptionBackend{Nothing})
      @ InfiniteExaModels ~/.julia/packages/InfiniteExaModels/Mouyz/src/infiniteopt_backend.jl:263
   [12] optimize!(model::InfiniteModel; ignore_optimize_hook::Bool, kwargs::@Kwargs{})
      @ InfiniteOpt ./Base_compiler.jl:0
   [13] optimize!(model::InfiniteModel)
      @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/backends.jl:445
   [14] macro expansion
      @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]
   [15] macro expansion
      @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:88 [inlined]
   [16] macro expansion
      @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [17] top-level scope
      @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:49

Test Problem 2: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:89
  Test threw exception
  Expression: isapprox(obj, objective_value(m), atol = tol)
  Unable to query `MathOptInterface.ObjectiveValue(1)` since up-to-date solution results are not available. This is likely because the transformation backend has not been built and optimized yet, or the model has been modified since the backend was optimized.
  Stacktrace:
   [1] error(s::String)
     @ Base ./error.jl:56
   [2] _check_result_is_current(model::InfiniteModel, func::MathOptInterface.ObjectiveValue)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:7 [inlined]
   [3] get_attribute(model::InfiniteModel, attr::MathOptInterface.ObjectiveValue)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:48
   [4] #objective_value#372
     @ ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:99 [inlined]
   [5] objective_value(model::InfiniteModel)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:98
   [6] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]
   [7] macro expansion
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:89 [inlined]
   [8] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [9] top-level scope
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:49

Test Problem 2: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:90
  Test threw exception
  Expression: all(isapprox.(yval, value(y), atol = tol))
  Unable to query `value` since up-to-date solution results are not available. This is likely because the transformation backend has not been built and optimized yet, or the model has been modified since the backend was optimized.
  Stacktrace:
   [1] error(s::String)
     @ Base ./error.jl:56
   [2] _check_result_is_current(model::InfiniteModel, func::typeof(value))
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:7 [inlined]
   [3] value(vref::GeneralVariableRef; kwargs::@Kwargs{})
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:312
   [4] value(vref::GeneralVariableRef)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:311
   [5] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]
   [6] macro expansion
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:90 [inlined]
   [7] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [8] top-level scope
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:49

Test Problem 2: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:91
  Test threw exception
  Expression: isapprox.(zval, value(z), atol = tol)
  Unable to query `value` since up-to-date solution results are not available. This is likely because the transformation backend has not been built and optimized yet, or the model has been modified since the backend was optimized.
  Stacktrace:
   [1] error(s::String)
     @ Base ./error.jl:56
   [2] _check_result_is_current(model::InfiniteModel, func::typeof(value))
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:7 [inlined]
   [3] value(vref::GeneralVariableRef; kwargs::@Kwargs{})
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:312
   [4] value(vref::GeneralVariableRef)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:311
   [5] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]
   [6] macro expansion
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:91 [inlined]
   [7] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [8] top-level scope
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:49

Test Problem 2: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:88
  Test threw exception
  Expression: (optimize!(m)).status == :first_order
  TypeError: in typeassert, expected Nothing, got a value of type Tuple{Vector{Int32}, Vector{Int32}}
  Stacktrace:
    [1] _Eval_H_CB(n::Int32, x_ptr::Ptr{Float64}, ::Int32, obj_factor::Float64, m::Int32, lambda_ptr::Ptr{Float64}, ::Int32, nele_hess::Int32, iRow::Ptr{Int32}, jCol::Ptr{Int32}, values_ptr::Ptr{Float64}, user_data::Ptr{IpoptProblem})
      @ Ipopt ~/.julia/packages/Ipopt/dJbDQ/src/C_wrapper.jl:126
    [2] (::Ipopt.var"#IpoptSolve##0#IpoptSolve##1"{IpoptProblem, Base.RefValue{Float64}})()
      @ Ipopt ~/.julia/packages/Ipopt/dJbDQ/src/C_wrapper.jl:408 [inlined]
    [3] disable_sigint(f::Ipopt.var"#IpoptSolve##0#IpoptSolve##1"{IpoptProblem, Base.RefValue{Float64}})
      @ Base ./c.jl:167
    [4] in(key::Symbol, v::Base.KeySet{Symbol, Dict{Symbol, Int64}})
      @ Base ~/.julia/packages/Ipopt/dJbDQ/src/C_wrapper.jl:407 [inlined]
    [5] solve!(solver::IpoptSolver, nlp::ExaModel{Float64, Vector{Float64}, Nothing, ExaModels.Objective{ExaModels.ObjectiveNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), ExaModels.ParIndexed{ExaModels.ParSource, :c}, ExaModels.Node2{typeof(*), ExaModels.Node1{typeof(abs2), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.Node1{typeof(cos), ExaModels.Var{Int64}}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}}, Matrix{@NamedTuple{c::Float64, group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}}, ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.ConstraintNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node1{typeof(sin), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, Float64}, ExaModels.Var{Int64}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{Int64}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.Var{Int64}}, ExaModels.Node2{typeof(*), Float64, ExaModels.ParIndexed{ExaModels.ParSource, :ip1}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Matrix{@NamedTuple{group_idx1::Int64, ip1::Float64, d_arg1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}, Int64}}, Int64}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx2::Int64, ip2::Float64, d_arg1::Float64}}, Int64}, Nothing}, stats::SolverCore.GenericExecutionStats{Float64, Vector{Float64}, Vector{Float64}, Any}; callback::NLPModelsIpopt.var"#15#16", kwargs::@Kwargs{print_level::Int64})
      @ NLPModelsIpopt ~/.julia/packages/NLPModelsIpopt/9iVBk/src/NLPModelsIpopt.jl:336
    [6] solve!
      @ ~/.julia/packages/NLPModelsIpopt/9iVBk/src/NLPModelsIpopt.jl:241 [inlined]
    [7] solve!(solver::IpoptSolver, model::ExaModel{Float64, Vector{Float64}, Nothing, ExaModels.Objective{ExaModels.ObjectiveNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), ExaModels.ParIndexed{ExaModels.ParSource, :c}, ExaModels.Node2{typeof(*), ExaModels.Node1{typeof(abs2), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.Node1{typeof(cos), ExaModels.Var{Int64}}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}}, Matrix{@NamedTuple{c::Float64, group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}}, ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.ConstraintNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node1{typeof(sin), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, Float64}, ExaModels.Var{Int64}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{Int64}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.Var{Int64}}, ExaModels.Node2{typeof(*), Float64, ExaModels.ParIndexed{ExaModels.ParSource, :ip1}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Matrix{@NamedTuple{group_idx1::Int64, ip1::Float64, d_arg1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}, Int64}}, Int64}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx2::Int64, ip2::Float64, d_arg1::Float64}}, Int64}, Nothing}; kwargs::@Kwargs{print_level::Int64})
      @ SolverCoreNLPModelsExt ~/.julia/packages/SolverCore/UI1dA/ext/SolverCoreNLPModelsExt.jl:60 [inlined]
    [8] initial_solve(type::Type{IpoptSolver}, backend::ExaTranscriptionBackend{Nothing}, options::Dict{Symbol, Any})
      @ InfiniteExaModelsIpopt ~/.julia/packages/InfiniteExaModels/Mouyz/ext/InfiniteExaModelsIpopt.jl:49
    [9] ht_keyindex(h::Dict{Symbol, Any}, key::Symbol)
      @ Base ~/.julia/packages/InfiniteExaModels/Mouyz/src/infiniteopt_backend.jl:265 [inlined]
   [10] haskey(h::Dict{Symbol, Any}, key::Symbol)
      @ Base ./timing.jl:503 [inlined]
   [11] optimize!(backend::ExaTranscriptionBackend{Nothing})
      @ InfiniteExaModels ~/.julia/packages/InfiniteExaModels/Mouyz/src/infiniteopt_backend.jl:263
   [12] optimize!(model::InfiniteModel; ignore_optimize_hook::Bool, kwargs::@Kwargs{})
      @ InfiniteOpt ./Base_compiler.jl:0
   [13] optimize!(model::InfiniteModel)
      @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/backends.jl:445
   [14] macro expansion
      @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]
   [15] macro expansion
      @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:88 [inlined]
   [16] macro expansion
      @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [17] top-level scope
      @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:49

Test Problem 2: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:89
  Test threw exception
  Expression: isapprox(obj, objective_value(m), atol = tol)
  Unable to query `MathOptInterface.ObjectiveValue(1)` since up-to-date solution results are not available. This is likely because the transformation backend has not been built and optimized yet, or the model has been modified since the backend was optimized.
  Stacktrace:
   [1] error(s::String)
     @ Base ./error.jl:56
   [2] _check_result_is_current(model::InfiniteModel, func::MathOptInterface.ObjectiveValue)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:7 [inlined]
   [3] get_attribute(model::InfiniteModel, attr::MathOptInterface.ObjectiveValue)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:48
   [4] #objective_value#372
     @ ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:99 [inlined]
   [5] objective_value(model::InfiniteModel)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:98
   [6] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]
   [7] macro expansion
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:89 [inlined]
   [8] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [9] top-level scope
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:49

Test Problem 2: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:90
  Test threw exception
  Expression: all(isapprox.(yval, value(y), atol = tol))
  Unable to query `value` since up-to-date solution results are not available. This is likely because the transformation backend has not been built and optimized yet, or the model has been modified since the backend was optimized.
  Stacktrace:
   [1] error(s::String)
     @ Base ./error.jl:56
   [2] _check_result_is_current(model::InfiniteModel, func::typeof(value))
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:7 [inlined]
   [3] value(vref::GeneralVariableRef; kwargs::@Kwargs{})
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:312
   [4] value(vref::GeneralVariableRef)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:311
   [5] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]
   [6] macro expansion
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:90 [inlined]
   [7] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [8] top-level scope
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:49

Test Problem 2: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:91
  Test threw exception
  Expression: isapprox.(zval, value(z), atol = tol)
  Unable to query `value` since up-to-date solution results are not available. This is likely because the transformation backend has not been built and optimized yet, or the model has been modified since the backend was optimized.
  Stacktrace:
   [1] error(s::String)
     @ Base ./error.jl:56
   [2] _check_result_is_current(model::InfiniteModel, func::typeof(value))
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:7 [inlined]
   [3] value(vref::GeneralVariableRef; kwargs::@Kwargs{})
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:312
   [4] value(vref::GeneralVariableRef)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:311
   [5] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]
   [6] macro expansion
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:91 [inlined]
   [7] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [8] top-level scope
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:49

Test Problem 2: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:88
  Test threw exception
  Expression: (optimize!(m)).status == :first_order
  TypeError: in typeassert, expected Nothing, got a value of type Tuple{Vector{Int32}, Vector{Int32}}
  Stacktrace:
    [1] _Eval_H_CB(n::Int32, x_ptr::Ptr{Float64}, ::Int32, obj_factor::Float64, m::Int32, lambda_ptr::Ptr{Float64}, ::Int32, nele_hess::Int32, iRow::Ptr{Int32}, jCol::Ptr{Int32}, values_ptr::Ptr{Float64}, user_data::Ptr{IpoptProblem})
      @ Ipopt ~/.julia/packages/Ipopt/dJbDQ/src/C_wrapper.jl:126
    [2] (::Ipopt.var"#IpoptSolve##0#IpoptSolve##1"{IpoptProblem, Base.RefValue{Float64}})()
      @ Ipopt ~/.julia/packages/Ipopt/dJbDQ/src/C_wrapper.jl:408 [inlined]
    [3] disable_sigint(f::Ipopt.var"#IpoptSolve##0#IpoptSolve##1"{IpoptProblem, Base.RefValue{Float64}})
      @ Base ./c.jl:167
    [4] in(key::Symbol, v::Base.KeySet{Symbol, Dict{Symbol, Int64}})
      @ Base ~/.julia/packages/Ipopt/dJbDQ/src/C_wrapper.jl:407 [inlined]
    [5] solve!(solver::IpoptSolver, nlp::ExaModel{Float64, Vector{Float64}, Nothing, ExaModels.Objective{ExaModels.ObjectiveNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), ExaModels.ParIndexed{ExaModels.ParSource, :c}, ExaModels.Node2{typeof(*), ExaModels.Var{Int64}, ExaModels.Node2{typeof(+), ExaModels.Node1{typeof(abs2), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.Node2{typeof(^), ExaModels.Var{Int64}, Int64}}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{NTuple{6, Int64}}}, Matrix{@NamedTuple{c::Float64, group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}}, ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.ConstraintNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node1{typeof(sin), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, Float64}, ExaModels.Var{Int64}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{Int64}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.Var{Int64}}, ExaModels.Node2{typeof(*), Float64, ExaModels.ParIndexed{ExaModels.ParSource, :ip1}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Matrix{@NamedTuple{group_idx1::Int64, ip1::Float64, d_arg1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}, Int64}}, Int64}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx2::Int64, ip2::Float64, d_arg1::Float64}}, Int64}, Nothing}, stats::SolverCore.GenericExecutionStats{Float64, Vector{Float64}, Vector{Float64}, Any}; callback::NLPModelsIpopt.var"#15#16", kwargs::@Kwargs{print_level::Int64})
      @ NLPModelsIpopt ~/.julia/packages/NLPModelsIpopt/9iVBk/src/NLPModelsIpopt.jl:336
    [6] solve!
      @ ~/.julia/packages/NLPModelsIpopt/9iVBk/src/NLPModelsIpopt.jl:241 [inlined]
    [7] solve!(solver::IpoptSolver, model::ExaModel{Float64, Vector{Float64}, Nothing, ExaModels.Objective{ExaModels.ObjectiveNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), ExaModels.ParIndexed{ExaModels.ParSource, :c}, ExaModels.Node2{typeof(*), ExaModels.Var{Int64}, ExaModels.Node2{typeof(+), ExaModels.Node1{typeof(abs2), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.Node2{typeof(^), ExaModels.Var{Int64}, Int64}}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{NTuple{6, Int64}}}, Matrix{@NamedTuple{c::Float64, group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}}, ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.ConstraintNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node1{typeof(sin), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, Float64}, ExaModels.Var{Int64}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{Int64}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.Var{Int64}}, ExaModels.Node2{typeof(*), Float64, ExaModels.ParIndexed{ExaModels.ParSource, :ip1}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Matrix{@NamedTuple{group_idx1::Int64, ip1::Float64, d_arg1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, ExaModels.ParIndexed{ExaModels.ParSource, :d_arg1}}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}, Int64}}, Int64}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx2::Int64, ip2::Float64, d_arg1::Float64}}, Int64}, Nothing}; kwargs::@Kwargs{print_level::Int64})
      @ SolverCoreNLPModelsExt ~/.julia/packages/SolverCore/UI1dA/ext/SolverCoreNLPModelsExt.jl:60 [inlined]
    [8] initial_solve(type::Type{IpoptSolver}, backend::ExaTranscriptionBackend{Nothing}, options::Dict{Symbol, Any})
      @ InfiniteExaModelsIpopt ~/.julia/packages/InfiniteExaModels/Mouyz/ext/InfiniteExaModelsIpopt.jl:49
    [9] ht_keyindex(h::Dict{Symbol, Any}, key::Symbol)
      @ Base ~/.julia/packages/InfiniteExaModels/Mouyz/src/infiniteopt_backend.jl:265 [inlined]
   [10] haskey(h::Dict{Symbol, Any}, key::Symbol)
      @ Base ./timing.jl:503 [inlined]
   [11] optimize!(backend::ExaTranscriptionBackend{Nothing})
      @ InfiniteExaModels ~/.julia/packages/InfiniteExaModels/Mouyz/src/infiniteopt_backend.jl:263
   [12] optimize!(model::InfiniteModel; ignore_optimize_hook::Bool, kwargs::@Kwargs{})
      @ InfiniteOpt ./Base_compiler.jl:0
   [13] optimize!(model::InfiniteModel)
      @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/backends.jl:445
   [14] macro expansion
      @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]
   [15] macro expansion
      @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:88 [inlined]
   [16] macro expansion
      @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [17] top-level scope
      @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:49

Test Problem 2: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:89
  Test threw exception
  Expression: isapprox(obj, objective_value(m), atol = tol)
  Unable to query `MathOptInterface.ObjectiveValue(1)` since up-to-date solution results are not available. This is likely because the transformation backend has not been built and optimized yet, or the model has been modified since the backend was optimized.
  Stacktrace:
   [1] error(s::String)
     @ Base ./error.jl:56
   [2] _check_result_is_current(model::InfiniteModel, func::MathOptInterface.ObjectiveValue)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:7 [inlined]
   [3] get_attribute(model::InfiniteModel, attr::MathOptInterface.ObjectiveValue)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:48
   [4] #objective_value#372
     @ ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:99 [inlined]
   [5] objective_value(model::InfiniteModel)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:98
   [6] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]
   [7] macro expansion
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:89 [inlined]
   [8] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [9] top-level scope
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:49

Test Problem 2: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:90
  Test threw exception
  Expression: all(isapprox.(yval, value(y), atol = tol))
  Unable to query `value` since up-to-date solution results are not available. This is likely because the transformation backend has not been built and optimized yet, or the model has been modified since the backend was optimized.
  Stacktrace:
   [1] error(s::String)
     @ Base ./error.jl:56
   [2] _check_result_is_current(model::InfiniteModel, func::typeof(value))
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:7 [inlined]
   [3] value(vref::GeneralVariableRef; kwargs::@Kwargs{})
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:312
   [4] value(vref::GeneralVariableRef)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:311
   [5] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]
   [6] macro expansion
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:90 [inlined]
   [7] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [8] top-level scope
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:49

Test Problem 2: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:91
  Test threw exception
  Expression: isapprox.(zval, value(z), atol = tol)
  Unable to query `value` since up-to-date solution results are not available. This is likely because the transformation backend has not been built and optimized yet, or the model has been modified since the backend was optimized.
  Stacktrace:
   [1] error(s::String)
     @ Base ./error.jl:56
   [2] _check_result_is_current(model::InfiniteModel, func::typeof(value))
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:7 [inlined]
   [3] value(vref::GeneralVariableRef; kwargs::@Kwargs{})
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:312
   [4] value(vref::GeneralVariableRef)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:311
   [5] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]
   [6] macro expansion
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:91 [inlined]
   [7] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [8] top-level scope
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:49
┌ Warning: Constrained measures can lead to poor performance with ExaModels.
└ @ InfiniteExaModels ~/.julia/packages/InfiniteExaModels/Mouyz/src/transform.jl:431

Parameter Function Problem: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:128
  Test threw exception
  Expression: (optimize!(m)).status == :first_order
  TypeError: in typeassert, expected Nothing, got a value of type Tuple{Vector{Int32}, Vector{Int32}}
  Stacktrace:
    [1] _Eval_H_CB(n::Int32, x_ptr::Ptr{Float64}, ::Int32, obj_factor::Float64, m::Int32, lambda_ptr::Ptr{Float64}, ::Int32, nele_hess::Int32, iRow::Ptr{Int32}, jCol::Ptr{Int32}, values_ptr::Ptr{Float64}, user_data::Ptr{IpoptProblem})
      @ Ipopt ~/.julia/packages/Ipopt/dJbDQ/src/C_wrapper.jl:126
    [2] (::Ipopt.var"#IpoptSolve##0#IpoptSolve##1"{IpoptProblem, Base.RefValue{Float64}})()
      @ Ipopt ~/.julia/packages/Ipopt/dJbDQ/src/C_wrapper.jl:408 [inlined]
    [3] disable_sigint(f::Ipopt.var"#IpoptSolve##0#IpoptSolve##1"{IpoptProblem, Base.RefValue{Float64}})
      @ Base ./c.jl:167
    [4] in(key::Symbol, v::Base.KeySet{Symbol, Dict{Symbol, Int64}})
      @ Base ~/.julia/packages/Ipopt/dJbDQ/src/C_wrapper.jl:407 [inlined]
    [5] solve!(solver::IpoptSolver, nlp::ExaModel{Float64, Vector{Float64}, Nothing, ExaModels.Objective{ExaModels.Objective{ExaModels.ObjectiveNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), ExaModels.ParIndexed{ExaModels.ParSource, :c}, ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}, ExaModels.ParameterNode{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{c::Float64, group_idx1::Int64, ip1::Float64}}}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), ExaModels.ParIndexed{ExaModels.ParSource, :c}, ExaModels.Node2{typeof(*), ExaModels.Node2{typeof(*), Float64, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.ParameterNode{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Matrix{@NamedTuple{c::Float64, group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}}, ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.ConstraintNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}, ExaModels.ParameterNode{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), ExaModels.ParameterNode{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}, ExaModels.ParameterNode{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.Node2{typeof(*), Float64, ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}, ExaModels.Node2{typeof(*), Float64, ExaModels.ParameterNode{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), ExaModels.ParameterNode{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.ParameterNode{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, Int64}, Int64}}}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), ExaModels.Node2{typeof(*), Float64, ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}, ExaModels.ParameterNode{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, Int64}}}}, ExaModels.Node2{typeof(*), ExaModels.Node2{typeof(*), Float64, ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}, ExaModels.ParameterNode{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, Int64}, Int64}}}}}, ExaModels.Node2{typeof(*), ExaModels.Node2{typeof(*), Float64, ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}, ExaModels.ParameterNode{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, Int64}, Int64}}}}}, ExaModels.Node2{typeof(*), ExaModels.Node2{typeof(*), Float64, ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}, ExaModels.ParameterNode{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, Int64}, Int64}}}}}, ExaModels.Node2{typeof(*), ExaModels.Node2{typeof(*), Float64, ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}, ExaModels.ParameterNode{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, Int64}, Int64}}}}}, ExaModels.Compressor{NTuple{5, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64}}, Int64}, Nothing}, stats::SolverCore.GenericExecutionStats{Float64, Vector{Float64}, Vector{Float64}, Any}; callback::NLPModelsIpopt.var"#15#16", kwargs::@Kwargs{print_level::Int64})
      @ NLPModelsIpopt ~/.julia/packages/NLPModelsIpopt/9iVBk/src/NLPModelsIpopt.jl:336
    [6] solve!
      @ ~/.julia/packages/NLPModelsIpopt/9iVBk/src/NLPModelsIpopt.jl:241 [inlined]
    [7] solve!(solver::IpoptSolver, model::ExaModel{Float64, Vector{Float64}, Nothing, ExaModels.Objective{ExaModels.Objective{ExaModels.ObjectiveNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), ExaModels.ParIndexed{ExaModels.ParSource, :c}, ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}, ExaModels.ParameterNode{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{c::Float64, group_idx1::Int64, ip1::Float64}}}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), ExaModels.ParIndexed{ExaModels.ParSource, :c}, ExaModels.Node2{typeof(*), ExaModels.Node2{typeof(*), Float64, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.ParameterNode{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Matrix{@NamedTuple{c::Float64, group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}}, ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.ConstraintNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}, ExaModels.ParameterNode{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), ExaModels.ParameterNode{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}, ExaModels.ParameterNode{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.Node2{typeof(*), Float64, ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}, ExaModels.Node2{typeof(*), Float64, ExaModels.ParameterNode{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), ExaModels.ParameterNode{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.ParameterNode{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, Int64}, Int64}}}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), ExaModels.Node2{typeof(*), Float64, ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}, ExaModels.ParameterNode{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, Int64}}}}, ExaModels.Node2{typeof(*), ExaModels.Node2{typeof(*), Float64, ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}, ExaModels.ParameterNode{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, Int64}, Int64}}}}}, ExaModels.Node2{typeof(*), ExaModels.Node2{typeof(*), Float64, ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}, ExaModels.ParameterNode{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, Int64}, Int64}}}}}, ExaModels.Node2{typeof(*), ExaModels.Node2{typeof(*), Float64, ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}, ExaModels.ParameterNode{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, Int64}, Int64}}}}}, ExaModels.Node2{typeof(*), ExaModels.Node2{typeof(*), Float64, ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}, ExaModels.ParameterNode{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, Int64}, Int64}}}}}, ExaModels.Compressor{NTuple{5, Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64}}, Int64}, Nothing}; kwargs::@Kwargs{print_level::Int64})
      @ SolverCoreNLPModelsExt ~/.julia/packages/SolverCore/UI1dA/ext/SolverCoreNLPModelsExt.jl:60 [inlined]
    [8] initial_solve(type::Type{IpoptSolver}, backend::ExaTranscriptionBackend{Nothing}, options::Dict{Symbol, Any})
      @ InfiniteExaModelsIpopt ~/.julia/packages/InfiniteExaModels/Mouyz/ext/InfiniteExaModelsIpopt.jl:49
    [9] ht_keyindex(h::Dict{Symbol, Any}, key::Symbol)
      @ Base ~/.julia/packages/InfiniteExaModels/Mouyz/src/infiniteopt_backend.jl:265 [inlined]
   [10] haskey(h::Dict{Symbol, Any}, key::Symbol)
      @ Base ./timing.jl:503 [inlined]
   [11] optimize!(backend::ExaTranscriptionBackend{Nothing})
      @ InfiniteExaModels ~/.julia/packages/InfiniteExaModels/Mouyz/src/infiniteopt_backend.jl:263
   [12] optimize!(model::InfiniteModel; ignore_optimize_hook::Bool, kwargs::@Kwargs{})
      @ InfiniteOpt ./Base_compiler.jl:0
   [13] optimize!(model::InfiniteModel)
      @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/backends.jl:445
   [14] top-level scope
      @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:97
   [15] macro expansion
      @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [16] macro expansion
      @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:128 [inlined]
   [17] macro expansion
      @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]

Parameter Function Problem: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:129
  Test threw exception
  Expression: isapprox(obj, objective_value(m), atol = tol)
  Unable to query `MathOptInterface.ObjectiveValue(1)` since up-to-date solution results are not available. This is likely because the transformation backend has not been built and optimized yet, or the model has been modified since the backend was optimized.
  Stacktrace:
   [1] error(s::String)
     @ Base ./error.jl:56
   [2] _check_result_is_current(model::InfiniteModel, func::MathOptInterface.ObjectiveValue)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:7 [inlined]
   [3] get_attribute(model::InfiniteModel, attr::MathOptInterface.ObjectiveValue)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:48
   [4] #objective_value#372
     @ ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:99 [inlined]
   [5] objective_value(model::InfiniteModel)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:98
   [6] top-level scope
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:97
   [7] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [8] macro expansion
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:129 [inlined]
   [9] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]

Parameter Function Problem: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:130
  Test threw exception
  Expression: all(isapprox.(vVal, value(v), atol = tol))
  Unable to query `value` since up-to-date solution results are not available. This is likely because the transformation backend has not been built and optimized yet, or the model has been modified since the backend was optimized.
  Stacktrace:
   [1] error(s::String)
     @ Base ./error.jl:56
   [2] _check_result_is_current(model::InfiniteModel, func::typeof(value))
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:7 [inlined]
   [3] value(vref::GeneralVariableRef; kwargs::@Kwargs{})
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:312
   [4] value(vref::GeneralVariableRef)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:311
   [5] top-level scope
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:97
   [6] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [7] macro expansion
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:130 [inlined]
   [8] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]

Parameter Function Problem: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:131
  Test threw exception
  Expression: all(isapprox.(zVal, value(z), atol = tol))
  Unable to query `value` since up-to-date solution results are not available. This is likely because the transformation backend has not been built and optimized yet, or the model has been modified since the backend was optimized.
  Stacktrace:
   [1] error(s::String)
     @ Base ./error.jl:56
   [2] _check_result_is_current(model::InfiniteModel, func::typeof(value))
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:7 [inlined]
   [3] value(vref::GeneralVariableRef; kwargs::@Kwargs{})
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:312
   [4] value(vref::GeneralVariableRef)
     @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/results.jl:311
   [5] top-level scope
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:97
   [6] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [7] macro expansion
     @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:131 [inlined]
   [8] macro expansion
     @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined]

Parameter updates: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:134
  Got exception outside of a @test
  TypeError: in typeassert, expected Nothing, got a value of type Tuple{Vector{Int32}, Vector{Int32}}
  Stacktrace:
    [1] _Eval_H_CB(n::Int32, x_ptr::Ptr{Float64}, ::Int32, obj_factor::Float64, m::Int32, lambda_ptr::Ptr{Float64}, ::Int32, nele_hess::Int32, iRow::Ptr{Int32}, jCol::Ptr{Int32}, values_ptr::Ptr{Float64}, user_data::Ptr{IpoptProblem})
      @ Ipopt ~/.julia/packages/Ipopt/dJbDQ/src/C_wrapper.jl:126
    [2] (::Ipopt.var"#IpoptSolve##0#IpoptSolve##1"{IpoptProblem, Base.RefValue{Float64}})()
      @ Ipopt ~/.julia/packages/Ipopt/dJbDQ/src/C_wrapper.jl:408 [inlined]
    [3] disable_sigint(f::Ipopt.var"#IpoptSolve##0#IpoptSolve##1"{IpoptProblem, Base.RefValue{Float64}})
      @ Base ./c.jl:167
    [4] in(key::Symbol, v::Base.KeySet{Symbol, Dict{Symbol, Int64}})
      @ Base ~/.julia/packages/Ipopt/dJbDQ/src/C_wrapper.jl:407 [inlined]
    [5] solve!(solver::IpoptSolver, nlp::ExaModel{Float64, Vector{Float64}, Nothing, ExaModels.Objective{ExaModels.Objective{ExaModels.ObjectiveNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), ExaModels.ParIndexed{ExaModels.ParSource, :c}, ExaModels.Node2{typeof(*), ExaModels.ParameterNode{Int64}, ExaModels.Node2{typeof(^), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Float64, ExaModels.Node1{typeof(abs2), ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}}}, Float64}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}}, Vector{@NamedTuple{c::Float64, group_idx1::Int64, ip1::Float64}}}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), ExaModels.ParIndexed{ExaModels.ParSource, :c}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node1{typeof(abs2), ExaModels.ParameterNode{Int64}}, ExaModels.Node2{typeof(*), ExaModels.Node2{typeof(*), Float64, ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}, ExaModels.ParameterNode{Int64}}}, ExaModels.Node1{typeof(abs2), ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{Int64}}}, Vector{@NamedTuple{c::Float64, group_idx1::Int64, ip1::Float64}}}, ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.ConstraintNull, ExaModels.SIMDFunction{ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}, ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Node1{typeof(abs2), ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}}}, ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{Int64}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64}}, Int64}, Nothing}, stats::SolverCore.GenericExecutionStats{Float64, Vector{Float64}, Vector{Float64}, Any}; callback::NLPModelsIpopt.var"#15#16", kwargs::@Kwargs{print_level::Int64})
      @ NLPModelsIpopt ~/.julia/packages/NLPModelsIpopt/9iVBk/src/NLPModelsIpopt.jl:336
    [6] solve!
      @ ~/.julia/packages/NLPModelsIpopt/9iVBk/src/NLPModelsIpopt.jl:241 [inlined]
    [7] solve!(solver::IpoptSolver, model::ExaModel{Float64, Vector{Float64}, Nothing, ExaModels.Objective{ExaModels.Objective{ExaModels.ObjectiveNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), ExaModels.ParIndexed{ExaModels.ParSource, :c}, ExaModels.Node2{typeof(*), ExaModels.ParameterNode{Int64}, ExaModels.Node2{typeof(^), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), Float64, ExaModels.Node1{typeof(abs2), ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}}, ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}}}, Float64}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}}, Vector{@NamedTuple{c::Float64, group_idx1::Int64, ip1::Float64}}}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), ExaModels.ParIndexed{ExaModels.ParSource, :c}, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node1{typeof(abs2), ExaModels.ParameterNode{Int64}}, ExaModels.Node2{typeof(*), ExaModels.Node2{typeof(*), Float64, ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}, ExaModels.ParameterNode{Int64}}}, ExaModels.Node1{typeof(abs2), ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{Int64}}}, Vector{@NamedTuple{c::Float64, group_idx1::Int64, ip1::Float64}}}, ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.ConstraintNull, ExaModels.SIMDFunction{ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}, ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{Int64, Int64, Int64}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Node1{typeof(abs2), ExaModels.Var{ExaModels.Node2{typeof(+), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}}}, ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}, ExaModels.Compressor{Tuple{Int64, Int64}}, ExaModels.Compressor{Tuple{Int64}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64}}, Int64}, Nothing}; kwargs::@Kwargs{print_level::Int64})
      @ SolverCoreNLPModelsExt ~/.julia/packages/SolverCore/UI1dA/ext/SolverCoreNLPModelsExt.jl:60 [inlined]
    [8] initial_solve(type::Type{IpoptSolver}, backend::ExaTranscriptionBackend{Nothing}, options::Dict{Symbol, Any})
      @ InfiniteExaModelsIpopt ~/.julia/packages/InfiniteExaModels/Mouyz/ext/InfiniteExaModelsIpopt.jl:49
    [9] ht_keyindex(h::Dict{Symbol, Any}, key::Symbol)
      @ Base ~/.julia/packages/InfiniteExaModels/Mouyz/src/infiniteopt_backend.jl:265 [inlined]
   [10] haskey(h::Dict{Symbol, Any}, key::Symbol)
      @ Base ./timing.jl:503 [inlined]
   [11] optimize!(backend::ExaTranscriptionBackend{Nothing})
      @ InfiniteExaModels ~/.julia/packages/InfiniteExaModels/Mouyz/src/infiniteopt_backend.jl:263
   [12] optimize!(model::InfiniteModel; ignore_optimize_hook::Bool, kwargs::@Kwargs{})
      @ InfiniteOpt ./Base_compiler.jl:0
   [13] optimize!(model::InfiniteModel)
      @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/backends.jl:445
   [14] top-level scope
      @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:135
   [15] macro expansion
      @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [16] macro expansion
      @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:145 [inlined]
   [17] include(mapexpr::Function, mod::Module, _path::String)
      @ Base ./Base.jl:327
   [18] IncludeInto
      @ ./Base.jl:328 [inlined]
   [19] macro expansion
      @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/runtests.jl:9 [inlined]
   [20] macro expansion
      @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [21] macro expansion
      @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/runtests.jl:9 [inlined]
   [22] macro expansion
      @ ./timing.jl:739 [inlined]
   [23] top-level scope
      @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/runtests.jl:395
   [24] include(mapexpr::Function, mod::Module, _path::String)
      @ Base ./Base.jl:327
   [25] top-level scope
      @ none:6
   [26] eval(m::Module, e::Any)
      @ Core ./boot.jl:517
   [27] exec_options(opts::Base.JLOptions)
      @ Base ./client.jl:318
   [28] _start()
      @ Base ./client.jl:593

Parameter function updates: Error During Test at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:164
  Got exception outside of a @test
  TypeError: in typeassert, expected Nothing, got a value of type Tuple{Vector{Int32}, Vector{Int32}}
  Stacktrace:
    [1] _Eval_H_CB(n::Int32, x_ptr::Ptr{Float64}, ::Int32, obj_factor::Float64, m::Int32, lambda_ptr::Ptr{Float64}, ::Int32, nele_hess::Int32, iRow::Ptr{Int32}, jCol::Ptr{Int32}, values_ptr::Ptr{Float64}, user_data::Ptr{IpoptProblem})
      @ Ipopt ~/.julia/packages/Ipopt/dJbDQ/src/C_wrapper.jl:126
    [2] (::Ipopt.var"#IpoptSolve##0#IpoptSolve##1"{IpoptProblem, Base.RefValue{Float64}})()
      @ Ipopt ~/.julia/packages/Ipopt/dJbDQ/src/C_wrapper.jl:408 [inlined]
    [3] disable_sigint(f::Ipopt.var"#IpoptSolve##0#IpoptSolve##1"{IpoptProblem, Base.RefValue{Float64}})
      @ Base ./c.jl:167
    [4] in(key::Symbol, v::Base.KeySet{Symbol, Dict{Symbol, Int64}})
      @ Base ~/.julia/packages/Ipopt/dJbDQ/src/C_wrapper.jl:407 [inlined]
    [5] solve!(solver::IpoptSolver, nlp::ExaModel{Float64, Vector{Float64}, Nothing, ExaModels.Objective{ExaModels.Objective{ExaModels.ObjectiveNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), ExaModels.ParIndexed{ExaModels.ParSource, :c}, ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}, ExaModels.ParameterNode{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{c::Float64, group_idx1::Int64, ip1::Float64}}}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), ExaModels.ParIndexed{ExaModels.ParSource, :c}, ExaModels.Node2{typeof(*), ExaModels.Node2{typeof(*), Float64, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.ParameterNode{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Matrix{@NamedTuple{c::Float64, group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}}, ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.ConstraintNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}, ExaModels.ParameterNode{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), ExaModels.ParameterNode{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}, ExaModels.ParameterNode{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.Node2{typeof(*), Float64, ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}, ExaModels.Node2{typeof(*), Float64, ExaModels.ParameterNode{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), ExaModels.ParameterNode{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.ParameterNode{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, Int64}, Int64}}}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, Nothing}, stats::SolverCore.GenericExecutionStats{Float64, Vector{Float64}, Vector{Float64}, Any}; callback::NLPModelsIpopt.var"#15#16", kwargs::@Kwargs{print_level::Int64})
      @ NLPModelsIpopt ~/.julia/packages/NLPModelsIpopt/9iVBk/src/NLPModelsIpopt.jl:336
    [6] solve!
      @ ~/.julia/packages/NLPModelsIpopt/9iVBk/src/NLPModelsIpopt.jl:241 [inlined]
    [7] solve!(solver::IpoptSolver, model::ExaModel{Float64, Vector{Float64}, Nothing, ExaModels.Objective{ExaModels.Objective{ExaModels.ObjectiveNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), ExaModels.ParIndexed{ExaModels.ParSource, :c}, ExaModels.Node2{typeof(*), ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}, ExaModels.ParameterNode{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{c::Float64, group_idx1::Int64, ip1::Float64}}}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(*), ExaModels.ParIndexed{ExaModels.ParSource, :c}, ExaModels.Node2{typeof(*), ExaModels.Node2{typeof(*), Float64, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.ParameterNode{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Matrix{@NamedTuple{c::Float64, group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}}, ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.Constraint{ExaModels.ConstraintNull, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}, ExaModels.ParameterNode{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), ExaModels.ParameterNode{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}, ExaModels.ParameterNode{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}, ExaModels.Node2{typeof(*), Float64, ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Var{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}, ExaModels.Node2{typeof(*), Float64, ExaModels.ParameterNode{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, ExaModels.SIMDFunction{ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(*), ExaModels.ParameterNode{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, ExaModels.Node2{typeof(*), Int64, ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx2}, Int64}}}, Int64}}}, ExaModels.ParameterNode{ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}}}, ExaModels.Var{ExaModels.Node2{typeof(+), Int64, ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(+), ExaModels.Node2{typeof(-), ExaModels.ParIndexed{ExaModels.ParSource, :group_idx1}, Int64}, Int64}, Int64}}}}, ExaModels.Compressor{Tuple{Int64}}, ExaModels.Compressor{Tuple{}}}, Vector{@NamedTuple{group_idx1::Int64, ip1::Float64, group_idx2::Int64, ip2::Float64}}, Int64}, Nothing}; kwargs::@Kwargs{print_level::Int64})
      @ SolverCoreNLPModelsExt ~/.julia/packages/SolverCore/UI1dA/ext/SolverCoreNLPModelsExt.jl:60 [inlined]
    [8] initial_solve(type::Type{IpoptSolver}, backend::ExaTranscriptionBackend{Nothing}, options::Dict{Symbol, Any})
      @ InfiniteExaModelsIpopt ~/.julia/packages/InfiniteExaModels/Mouyz/ext/InfiniteExaModelsIpopt.jl:49
    [9] ht_keyindex(h::Dict{Symbol, Any}, key::Symbol)
      @ Base ~/.julia/packages/InfiniteExaModels/Mouyz/src/infiniteopt_backend.jl:265 [inlined]
   [10] haskey(h::Dict{Symbol, Any}, key::Symbol)
      @ Base ./timing.jl:503 [inlined]
   [11] optimize!(backend::ExaTranscriptionBackend{Nothing})
      @ InfiniteExaModels ~/.julia/packages/InfiniteExaModels/Mouyz/src/infiniteopt_backend.jl:263
   [12] optimize!(model::InfiniteModel; ignore_optimize_hook::Bool, kwargs::@Kwargs{})
      @ InfiniteOpt ./Base_compiler.jl:0
   [13] optimize!(model::InfiniteModel)
      @ InfiniteOpt ~/.julia/packages/InfiniteOpt/b0fSF/src/backends.jl:445
   [14] top-level scope
      @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:166
   [15] macro expansion
      @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [16] macro expansion
      @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/solve.jl:186 [inlined]
   [17] include(mapexpr::Function, mod::Module, _path::String)
      @ Base ./Base.jl:327
   [18] IncludeInto
      @ ./Base.jl:328 [inlined]
   [19] macro expansion
      @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/runtests.jl:9 [inlined]
   [20] macro expansion
      @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined]
   [21] macro expansion
      @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/runtests.jl:9 [inlined]
   [22] macro expansion
      @ ./timing.jl:739 [inlined]
   [23] top-level scope
      @ ~/.julia/packages/InfiniteExaModels/Mouyz/test/runtests.jl:395
   [24] include(mapexpr::Function, mod::Module, _path::String)
      @ Base ./Base.jl:327
   [25] top-level scope
      @ none:6
   [26] eval(m::Module, e::Any)
      @ Core ./boot.jl:517
   [27] exec_options(opts::Base.JLOptions)
      @ Base ./client.jl:318
   [28] _start()
      @ Base ./client.jl:593
Test Summary:                | Pass  Error  Total     Time
Solve Tests                  |   16     36     52  4m26.0s
  Test Problem 1             |    4     10     14  3m43.1s
  Test Problem 2             |   10     20     30    15.3s
  Parameter Function Problem |    2      4      6    15.3s
  Parameter updates          |           1      1     7.9s
  Parameter function updates |           1      1     2.3s
RNG of the outermost testset: Random.Xoshiro(0x557bb2dcff586bd1, 0x8a3577fbaac74625, 0x06be382f6b44f570, 0xe7a76a6648c4f738, 0x6b671c891569cbf8)
ERROR: LoadError: Some tests did not pass: 16 passed, 0 failed, 36 errored, 0 broken.
in expression starting at /home/pkgeval/.julia/packages/InfiniteExaModels/Mouyz/test/runtests.jl:9

Testing failed after 599.77s

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

PkgEval failed after 863.74s: package tests unexpectedly errored