diff --git a/.github/dependabot.yml b/.github/dependabot.yml index 9b09538..1b23ebc 100644 --- a/.github/dependabot.yml +++ b/.github/dependabot.yml @@ -9,3 +9,9 @@ updates: directory: "/" schedule: interval: "weekly" + ignore: + # The v5→v7 bump silently broke coverage uploads in the sibling + # DecisionRules.jl repo. Keep codecov-action pinned until a deliberate, + # verified migration — see the comment in .github/workflows/CI.yml. + - dependency-name: "codecov/codecov-action" + update-types: ["version-update:semver-major"] diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index d6b04cb..be1a6df 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -17,6 +17,7 @@ jobs: permissions: actions: write contents: read + id-token: write # OIDC token for tokenless Codecov uploads (see codecov step) strategy: fail-fast: false matrix: @@ -37,8 +38,22 @@ jobs: - uses: julia-actions/julia-buildpkg@v1 - uses: julia-actions/julia-runtest@v1 - uses: julia-actions/julia-processcoverage@v1 - - uses: codecov/codecov-action@v7 + # Pinned to v5: codecov-action@v7 silently stopped uploading coverage in + # the sibling DecisionRules.jl repo (Codecov "Missing Head Commit" on + # PRs); v5 is the last version verified to upload from this workflow + # shape. Before re-bumping, migrate deliberately and confirm a commit + # appears on Codecov. + # Authentication uses OIDC (`use_oidc` + the job's `id-token: write` + # permission) because the CODECOV_TOKEN secret is not set in this repo + # ("Token length: 0" in CI) and tokenless uploads are rejected on + # protected branches. OIDC requires the Codecov GitHub App to be + # installed for the organization AND this repository to be activated on + # codecov.io (it currently is not); if uploads fail with an OIDC error, + # either install the app + activate the repo, or set the CODECOV_TOKEN + # secret and replace `use_oidc` with `token: ${{ secrets.CODECOV_TOKEN }}`. + - uses: codecov/codecov-action@v5 with: files: lcov.info - token: ${{ secrets.CODECOV_TOKEN }} - fail_ci_if_error: false + use_oidc: true + # Fail loudly so upload breakage is visible instead of silent. + fail_ci_if_error: true diff --git a/.gitignore b/.gitignore index a432b01..92a8236 100644 --- a/.gitignore +++ b/.gitignore @@ -42,3 +42,13 @@ logs/ # Slurm batch scripts (user-specific, not part of the package) *.sbatch *.sh +examples/HydroPowerModels/results/ +*strong.json + +# Generated evaluation artifacts: per-policy physical audit dumps and result +# shards. They are reproducible from the frozen case plus a checkpoint, they are +# bulky, and they are specific to one run — so they stay out of the package. +# The small reproducibility artifact that DOES belong in it is +# examples/HydroPowerModels/bolivia/case_manifest.json, which is tracked. +examples/**/audit/ +examples/**/results/ diff --git a/Project.toml b/Project.toml index 42ea84c..f07852b 100644 --- a/Project.toml +++ b/Project.toml @@ -1,33 +1,42 @@ name = "DecisionRulesExa" uuid = "7c3e91a4-d8f2-4b6a-9e15-a2c4f7b80d53" -authors = ["Andrew Rosemberg and contributors"] version = "0.1.0" +authors = ["Andrew Rosemberg and contributors"] [deps] -ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" +CSV = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b" CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" +ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" ExaModels = "1037b233-b668-4ce9-9b63-f9f681f55dd2" Flux = "587475ba-b771-5e3f-ad9e-33799f191a9c" +JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" +CUDSS = "45b445bb-4962-46a0-9369-b4df9d0f772e" +KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c" LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" MadNLP = "2621e9c9-9eb4-46b1-8089-e8c72242dfb6" MadNLPGPU = "d72a61cc-809d-412f-99be-fd81f4b8a598" NLPModels = "a4795742-8479-5a88-8948-cc11e1c8c1a6" Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" +Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" [compat] +CSV = "0.10.16" CUDA = "6" ChainRulesCore = "1.26" ExaModels = "0.11" Flux = "0.16" +JSON = "1.6.1" MadNLP = "0.10" MadNLPGPU = "0.10" NLPModels = "0.21" +Tables = "1.12.1" Zygote = "0.7" julia = "1.10, 1.11, 1.12" [extras] +Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" [targets] -test = ["Test"] +test = ["Test", "Statistics"] diff --git a/README.md b/README.md index a06eca1..b67b5af 100644 --- a/README.md +++ b/README.md @@ -59,6 +59,16 @@ train_tsddr( ) ``` +> **Note on the uncertainty parameter**: `train_tsddr` writes the full sampled +> trajectory (length `T * nw`) into `p_uncertainty` with +> `ExaModels.set_parameter!`, which enforces an exact size match (ExaModels ≥ +> 0.11). The `p_w` built by `build_deterministic_equivalent` / +> `build_linear_tracking_problem` holds only the `(T - 1) * nw` dynamics +> entries, so for `train_tsddr` your NLP needs an uncertainty parameter of +> length `T * nw` (as the Hydro example's `p_inflow` is). See the +> `"train_tsddr open-loop smoke test"` testset in `test/runtests.jl` for a +> minimal full-length variant of the problem above. + For GPU, replace `backend = nothing` with `backend = CUDABackend()` and add `linear_solver = CUDSSSolver` to `madnlp_kwargs`. ## What you need to provide @@ -71,7 +81,70 @@ For a custom problem you need: - **An uncertainty sampler** `() -> w_flat` returning a flat `Float32`/`Float64` vector of length `T * nw`. - **A Flux policy** (LSTM or MLP) mapping `(w_t, x_{t-1})` to target `x_t` at each stage. -The package provides `build_deterministic_equivalent` for generic problems and `build_linear_tracking_problem` as a ready-made demo. For domain-specific models (power systems, robotics), build the ExaModels NLP directly — see `examples/HydroPowerModels/` for a complete AC-OPF example. +The package provides `build_deterministic_equivalent` for generic problems and `build_linear_tracking_problem` as a ready-made demo. For domain-specific models, build the ExaModels NLP directly; `examples/BatteryStorageOPF/` contains an AC-OPF battery example. + +## Strict reachable target equality + +The usual TS-DDR deterministic equivalent uses slack-penalized target +constraints, + +```text +x_t - pi_theta(w_t, x_{t-1}) = delta_t, +objective += rho * penalty(delta_t). +``` + +This is the right default for open-loop target trajectories and for cases where +the policy can request states that are not reachable from the previous realized +state. The target multipliers are then gradients of the penalized projection +problem, so their quality depends on the penalty calibration. + +For policies whose output is guaranteed to lie in a one-stage reachable state +set, a stricter formulation is possible: + +```text +x_t = pi_theta(w_t, x_{t-1}), pi_theta(w_t, x_{t-1}) in R(w_t, x_{t-1}). +``` + +In that case the deterministic equivalent does not need target slack variables +or target penalties. The multiplier on the equality is the local envelope +sensitivity of the true stage problem with respect to the policy-imposed next +state, not the sensitivity of a penalized approximation. This is useful when: + +- users can define a differentiable or piecewise differentiable map into a + subset of the one-stage reachable set; +- total recourse is guaranteed by the model for every state produced by that + map. + +The package supports two ways to make strict mode safe: + +- **Embedded strict DE** ([`train_tsddr_embedded`](@ref), + [`build_embedded_deterministic_equivalent`](@ref)) evaluates the policy inside + the NLP against realized states, so the policy always sees the state from + which its next target must be reachable. +- **Regular strict DE with reachable rollout** computes targets before solving + the NLP, but starts from the true initial state and feeds the previous target + back to the reachable policy. If + `x̂_t ∈ R(x̂_{t-1}, w_t)` and `x̂_0 = x_0`, the full target path is feasible by + induction. The strict equality then forces the realized path to equal that + reachable target path. + +The published hydro case study uses the second path; see +[`examples/HydroPowerModels`](examples/HydroPowerModels). + +Do not use strict equality for a generic open-loop target policy. For +unreachable targets, the slack-penalty formulation is the robust fallback. + +The reachable map depends on the incoming state, and that dependence **must be +differentiated**. Declaring the interval endpoints non-differentiable still +produces a gradient and still lowers the loss, while descending a different +direction — measured on the hydro case, 6% of the true magnitude and 48 degrees +off. Check the complete actor gradient against finite differences before +drawing hyperparameter conclusions from it. + +The hydro reachable policy keeps recurrence over inflows only. Optional +`combiner_layers` / `DR_HEAD_LAYERS` add a nonlinear feed-forward map from +`[encoded_inflow; reservoir_state]` to targets without adding recurrence over +the state input. ## Parallel GPU solves @@ -217,7 +290,24 @@ Choose DecisionRules.jl when: - [`examples/end_to_end_cpu.jl`](examples/end_to_end_cpu.jl) — minimal CPU demo with a linear tracking problem - [`examples/end_to_end_gpu.jl`](examples/end_to_end_gpu.jl) — same demo on GPU with CUDSS -- [`examples/HydroPowerModels/`](examples/HydroPowerModels/) — full multi-stage hydrothermal scheduling with DC and AC OPF +- [`examples/BatteryStorageOPF/`](examples/BatteryStorageOPF/) — reproducible PGLib AC-OPF cases with linear battery storage + +## Repository Map + +| Path | Purpose | +|---|---| +| `src/DecisionRulesExa.jl` | Module entrypoint and public exports | +| `src/policy.jl` | MLP, state-conditioned LSTM policies, bounded target policies, nonlinear target heads | +| `src/deterministic_equivalent.jl` | Generic open-loop deterministic-equivalent builder and solve helpers | +| `src/embedded_deterministic_equivalent.jl` | Generic embedded-policy deterministic equivalent with nonlinear oracle | +| `src/training.jl` | `train_tsddr`, embedded training, solver retry/warm-start handling | +| `src/rollout.jl` | Stage-wise rollout evaluation for ExaModels problems | +| `src/critic_control_variate.jl` | Scalar critic/control-variate helpers | +| `src/utils.jl` | Indexing and small shared utilities | +| `examples/end_to_end_cpu.jl` | Minimal CPU training demo | +| `examples/end_to_end_gpu.jl` | Minimal GPU training demo | +| `examples/BatteryStorageOPF/` | PGLib AC-OPF battery-storage example | +| `test/runtests.jl` | Unit and smoke tests | ## Citation diff --git a/examples/BatteryStorageOPF/.gitignore b/examples/BatteryStorageOPF/.gitignore new file mode 100644 index 0000000..be45634 --- /dev/null +++ b/examples/BatteryStorageOPF/.gitignore @@ -0,0 +1,5 @@ +# Cases are CONSTRUCTED, never committed. Every artifact under case/ is a pure +# function of the builder in `build_battery_case.jl` plus its recorded seeds, so +# committing it would ship a second, drifting source of truth for the case. +# The manifest hashes belong in the phase record, not in git. +case/ diff --git a/examples/BatteryStorageOPF/Project.toml b/examples/BatteryStorageOPF/Project.toml new file mode 100644 index 0000000..bb5b77b --- /dev/null +++ b/examples/BatteryStorageOPF/Project.toml @@ -0,0 +1,41 @@ +[compat] +CUDA = "6" +CUDSS = "0.7, 0.8" +ExaModels = "0.11" +Flux = "0.16" +JLD2 = "0.5, 0.6" +JSON = "0.21, 1" +MadNLP = "0.10" +MadNLPGPU = "0.10" +Optimisers = "0.4" +StableRNGs = "1" +Zygote = "0.7" +julia = "1.11, 1.12" + +[deps] +CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" +CUDSS = "45b445bb-4962-46a0-9369-b4df9d0f772e" +DecisionRulesExa = "7c3e91a4-d8f2-4b6a-9e15-a2c4f7b80d53" +ExaModels = "1037b233-b668-4ce9-9b63-f9f681f55dd2" +Flux = "587475ba-b771-5e3f-ad9e-33799f191a9c" +JLD2 = "033835bb-8acc-5ee8-8aae-3f567f8a3819" +JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" +KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c" +LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +MadNLP = "2621e9c9-9eb4-46b1-8089-e8c72242dfb6" +MadNLPGPU = "d72a61cc-809d-412f-99be-fd81f4b8a598" +Optimisers = "3bd65402-5787-11e9-1adc-39752487f4e2" +Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7" +Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" +SHA = "ea8e919c-243c-51af-8825-aaa63cd721ce" +StableRNGs = "860ef19b-820b-49d6-a774-d7a799459cd3" +Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" +Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" +Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" +cuDNN = "02a925ec-e4fe-4b08-9a7e-0d78e3d38ccd" + +[extras] +CUDA_Runtime_jll = "76a88914-d11a-5bdc-97e0-2f5a05c973a2" + +[sources.DecisionRulesExa] +path = "../.." diff --git a/examples/BatteryStorageOPF/README.md b/examples/BatteryStorageOPF/README.md new file mode 100644 index 0000000..5b7b54d --- /dev/null +++ b/examples/BatteryStorageOPF/README.md @@ -0,0 +1,191 @@ +# Battery-storage AC-OPF — ExaModels / GPU engine + +This example is the GPU half of the multistage battery-storage study: a +true-ACP, strict-target deterministic equivalent written directly in ExaModels, +the strict reachable policy, and the TS-DDR trainer that drives them. + +The scientific narrative lives in the documentation. This file says how to run +things and what each file is for. + +The CPU half — the PGLib case builder, the PowerModels battery problem +specification and the stock SDDP baseline — lives in +`DecisionRules.jl/examples/BatteryStorageOPF`. The two packages are independent: +neither loads the other. They share the frozen case bytes and two source files +(`battery_case.jl`, `battery_solution_schema.jl`) as copies whose byte identity +is asserted whenever the case is rebuilt there. + +## What is written by hand here, and why + +This is the ONLY manually written network formulation in the project, and it +exists because there is no equally validated PowerModels-to-ExaModels bridge. +Its correctness is not asserted, it is measured: every physical variable is +differenced against the actual `PowerModels.ACPPowerModel` built from the same +frozen case, and the physical residuals of both solutions are recomputed +independently of either engine. + +There is no SOC-WR model here. SDDP does not run through this engine, and TS-DDR +trains and evaluates on true ACP throughout. + +There is exactly ONE formulation: strict. No soft-target, no penalized-target +and no target-deficit variant exists here or anywhere else in the supported +workflow. + +## Files + +| file | role | +|---|---| +| `battery_case.jl` | the frozen case contract, including the FROZEN FINITE DEMAND SUPPORT this engine trains from. **Byte-identical copy in the JuMP package**, where it is built. | +| `battery_solution_schema.jl` | the shared solution schema and the engine-neutral physical residuals. **Byte-identical copy in the JuMP package.** | +| `battery_exa.jl` | the network parse (arbitrary, nonconsecutive component identifiers) and the multistage strict true-ACP deterministic equivalent, its parameter updates, its target multipliers and its solution extraction | +| `battery_reachable_policy.jl` | the strict policy: recurrent encoder over observed demand, state-conditioned head, and the differentiable affine map into the one-stage reachable interval | +| `train_battery_exa_strict.jl` | the single parameterized training entry point, plus the rollout, the panel evaluation, checkpointing and device handling that the correctness gates share | +| `test/runtests.jl` | the consolidated regression suite | +| `case//` | the frozen artifacts, mirrored from the JuMP package | + +## Commands + +```bash +# consolidated regression suite (CPU) +julia --project=. test/runtests.jl + +# the same suite on a GPU +DR_BAT_DEVICE=gpu julia --project=. test/runtests.jl + +# a short strict training smoke +DR_BAT_STAGES=4 DR_BAT_EPOCHS=1 DR_BAT_BATCHES=2 DR_BAT_TRAJ=1 \ +DR_BAT_ENCODER=8 DR_BAT_HEAD=12 DR_BAT_EVAL_EVERY=2 DR_BAT_EVAL_COLS=1,2 \ + julia --project=. -t auto train_battery_exa_strict.jl + +# a full strict training stage on a GPU +DR_BAT_DEVICE=gpu julia --project=. -t auto train_battery_exa_strict.jl +``` + +## Environment variables + +One training stage is fully parameterized, which is what will let a declarative +lineage driver replay a published schedule rather than a narrative. + +| variable | meaning | default | +|---|---|---| +| `DR_BAT_CASE_DIR` | frozen case directory | `case/pglib_opf_case14_ieee` | +| `DR_BAT_STAGES` | horizon `T` | 24 | +| `DR_BAT_EPOCHS`, `DR_BAT_BATCHES` | update budget (`epochs × batches` gradient steps) | 2, 5 | +| `DR_BAT_TRAJ` | trajectories per gradient step | 2 | +| `DR_BAT_LR`, `DR_BAT_LR_FINAL` | cosine learning-rate ramp | 1e-3, 1e-4 | +| `DR_BAT_ENCODER`, `DR_BAT_HEAD` | encoder and head widths, comma separated | `64,64`, `128,128` | +| `DR_BAT_EVAL_EVERY`, `DR_BAT_EVAL_COLS` | screening-panel cadence and its protocol columns | 5, `1,2,3,4` | +| `DR_BAT_MAX_RECOURSE` | physical admissibility tolerance, pu | 1e-6 | +| `DR_BAT_SEED` | training seed | 20260804 | +| `DR_BAT_DEVICE` | `cpu` or `gpu` | `cpu` | +| `DR_BAT_CHECKPOINT` | checkpoint path | `battery_policy.jld2` | + +## The demand this engine trains on + +This engine never sees a demand sampler. What it reads is the frozen finite +support in `demand.json`: for every stage, a list of JOINT multiplier vectors +over the case's loads with explicit probabilities, hashed and mirrored +byte-identically from the JuMP package. + +That is not a convenience. Both methods of the study train from finite support — +SDDP enumerates it in its backward pass, TS-DDR samples atom indices from it in +its trajectories — and if each were allowed to discretize a continuous authoring +law on its own, the two would face two different stochastic programs while every +report still said "the same demand process". `support_digest` is recomputed here +on load and checked against the manifest, so "the two engines consumed the same +support" is verified rather than intended. + +Three consequences for this engine: + +- the support is STAGE-DEPENDENT in general (`K_t` may differ across stages), so + a training trajectory draws each stage's atom from that stage's own + probabilities; +- the multiplier is per LOAD, so the realized per-bus demand is the scaled loads + AGGREGATED to the bus, not a bus-level factor — anything else would average + away a regional or per-load structure and silently change the problem; +- the stage clock feature the policy is given uses the period the support + records, and stage indices outside the frozen horizon are an error rather than + a wrap. + +## Generators that exist in some stages and not others + +A case may declare, for any generator, a per-stage AVAILABILITY schedule: a +vector of multipliers under the `stage_availability` key of that generator's row +in `network.json`, applied to `pmin`, `pmax`, `qmin` and `qmax` alike, so an +entry of `0` takes the unit out of service completely — active and reactive — +rather than leaving something that cannot generate but can still hold up a +voltage for free. + +The convention is OPTIONAL and additive: a generator that carries no schedule is +available in every stage, and a case built before the convention existed produces +bit-identical variable bounds today. Because the schedule lives inside +`network.json`, it is covered by the case digest and travels with the case. + +The JuMP package applies it to the parsed network just before PowerModels +instantiates one stage. This engine builds every stage of the horizon in ONE +model, so it applies the multiplier to each stage's generator variable bounds +instead — `build_battery_exa` takes a `stages` keyword naming which CASE stage +each of its `T` model positions is (`1:T` by default, a window such as `[2]` for +a continuation problem solved on its own). Three consequences: + +- the model's SHAPE never depends on the schedule. The unit keeps its variables, + its cost row and its position in every flat array, and only its bounds close; + `gen_status` is deliberately untouched, because PowerModels drops an + out-of-service generator from `ref` and that would change the variable set from + one stage to the next in the JuMP engine. +- the schedule is DATA. It reaches the model through `lvar`/`uvar` and nothing + else — no objective term, no constraint coefficient, no parameter — so it lies + on no automatic-differentiation path, and the trajectory multipliers the + trainer consumes are still exactly the derivative of the solved value. +- a case WITH a schedule may only be solved on the window it was built for. + `assert_stage_window`, called from `strict_solve!`, fails closed rather than + silently solving stage 5 with stage 1's availability; a case without a schedule + accepts every offset exactly as it always did. + +A schedule that is not a non-empty vector, a multiplier that is not finite or +lies outside `[0, 1]`, inconsistent bounds on a scheduled unit, and a stage the +schedule does not cover are all errors at parse or build time. + +## Selection rule + +A checkpoint is written only when a COMPLETE screening-panel evaluation improves +on the best complete evaluation so far. Complete means every panel column +solved AND the worst physical recourse on every column is within +`DR_BAT_MAX_RECOURSE`. Averaging the columns that happened to succeed would +report a policy that does not exist, and a policy that leans on the recourse is +not admissible however cheap it looks. + +The training loss, the screening-panel rollout and an SDDP bound are three +distinct signals and are never compared in absolute level. + +## Devices and precision + +`DR_BAT_DEVICE=gpu` moves the policy with `Flux.gpu`, builds the ExaModels core +on a CUDA backend and selects `MadNLPGPU.CUDSSSolver`. Three failure modes are +checked rather than assumed: + +- `Flux.gpu` is a silent no-op without cuDNN, so `cuDNN` is imported and + `assert_device` verifies that every trainable array and the recurrent state + really are device arrays; +- `MadNLPGPU.CUDSSSolver` is `nothing` unless CUDSS.jl has been loaded, which is + checked before it is passed to the solver; +- the ExaModels model stays in `Float64` on both devices; the policy is + `Float32` for training and can be promoted with `Flux.f64` for + finite-difference work. + +On a cluster whose NVIDIA driver is newer than the runtime CUDA.jl can +auto-select, `CUDA.functional()` returns false with a "JLLs were precompiled +without an NVIDIA driver present" message. Pin the runtime once per environment +with `CUDA.set_runtime_version!(v"12.6")` — this writes a machine-local +`LocalPreferences.toml`, which is not part of the published example. + +## The solver is fresh on every solve + +`solve!` builds a new MadNLP solver each time, deliberately. PGLib cases contain +synchronous condensers whose active-power box is exactly `[0, 0]`, MadNLP's +default `fixed_variable_treatment` removes such variables from its internal +primal vector, and its re-solve path then fails to map a full-length starting +point into the reduced one. The only re-solve configuration that works widens +those boxes by about `1e-8`, which makes this engine's feasible set larger than +the PowerModels model it is validated against. Correctness wins; the model +itself (sparsity pattern, derivative kernels) is still built once and reused, +and a fresh 24-stage solve of the correctness-phase case takes about 0.2 s. diff --git a/examples/BatteryStorageOPF/battery_case.jl b/examples/BatteryStorageOPF/battery_case.jl new file mode 100644 index 0000000..1250df5 --- /dev/null +++ b/examples/BatteryStorageOPF/battery_case.jl @@ -0,0 +1,1525 @@ +# battery_case.jl +# +# Frozen case contract for the multistage battery-storage AC-OPF study. +# +# This file is the SINGLE source of truth for what "the case" is, and it is +# shipped BYTE-IDENTICALLY in both public engines (DecisionRules.jl, the +# JuMP/PowerModels/SDDP engine, and DecisionRulesExa.jl, the ExaModels/GPU +# engine). Neither engine may re-derive a battery parameter, a demand +# realization, or a scenario index on its own: both read them from here, so a +# disagreement between the engines can never be a disagreement about the case. +# +# It therefore depends only on JSON, SHA, StableRNGs and the Julia standard +# library. In particular it does NOT depend on PowerModels, PGLib or +# Distributions: those are needed to BUILD the frozen artifacts (see +# `battery_demand.jl` and `build_battery_case.jl`, which +# exist only in the JuMP engine), never to READ them. +# +# Artifacts of one case live in one directory: +# +# /network.json the parsed PGLib network, per-unit, verbatim +# /batteries.json battery placement and parameters +# /demand.json the FROZEN finite demand support +# /case_manifest.json units, counts, stage duration and SHA-256s +# +# Every number that both engines must agree on is in one of those four files. +# +# THE DEMAND CONTRACT, stated once. +# The authoring sampler (a `Distribution`, a callable, a regional group model — +# see `battery_demand.jl`) is NOT part of the case. What is frozen, hashed and +# mirrored is its FINITE SUPPORT: for every stage t, a list of joint multiplier +# vectors over the case's loads together with their probabilities. Both SDDP and +# TS-DDR train from those bytes and neither is permitted to resample or +# rediscretize the authoring sampler. That is what makes "the two methods faced +# the same stochastic program" a checkable statement rather than an intention. + +using JSON +using SHA +using StableRNGs +using Printf + +# ───────────────────────────────────────────────────────────────────────────── +# Schema tags +# +# Every artifact carries a schema string. A loader that meets an unknown schema +# FAILS rather than guessing, because a silently-shifted field is exactly the +# class of defect that makes two engines solve two different problems. +# +# The demand artifact is at schema 2: schema 1 carried a single scalar +# multiplier per stage, which cannot express a joint per-load realization. +# ───────────────────────────────────────────────────────────────────────────── + +const BATTERY_NETWORK_SCHEMA = "battery_storage_opf/network/1" +const BATTERY_BATTERY_SCHEMA = "battery_storage_opf/batteries/2" +const BATTERY_DEMAND_SCHEMA = "battery_storage_opf/demand/2" +const BATTERY_MANIFEST_SCHEMA = "battery_storage_opf/manifest/2" + +""" + STAGE_AVAILABILITY_KEY + +Name of the optional generator field that carries a per-stage availability +schedule: `gen[STAGE_AVAILABILITY_KEY][t]` is a nonnegative multiplier applied to +that generator's active and reactive limits at stage `t` by +[`apply_stage_availability!`](@ref). + +# Notes +The schedule lives INSIDE the network table rather than beside it in an artifact +of its own, for one reason: the frozen case hashes `network.json`, so a schedule +carried there is covered by the case digest, travels with the case to every +consumer, and cannot drift out of step with the network it describes. A separate +artifact would have needed its own hash, its own read-back check and its own +statement of which generator each row refers to. + +The network schema is unchanged because the field is OPTIONAL and additive: a +generator that does not carry it is available in every stage, so every case built +before this convention existed still means exactly what it meant then. +""" +const STAGE_AVAILABILITY_KEY = "stage_availability" + +# ───────────────────────────────────────────────────────────────────────────── +# Canonical JSON +# +# `JSON.print` iterates a `Dict` in hash order, so writing the same object twice +# from two processes can produce two different byte strings and destroy the +# point of hashing an artifact. The emitter below sorts object keys and prints +# every scalar through a round-tripping representation, which makes the bytes a +# pure function of the value. +# ───────────────────────────────────────────────────────────────────────────── + +""" + canonical_json(value) -> String + +Serialize `value` to JSON whose bytes depend only on the value, not on +dictionary iteration order or on floating-point printing defaults. + +# Arguments +- `value`: any nesting of `AbstractDict{<:AbstractString}`, `AbstractVector`, + `AbstractString`, `Bool`, `Integer`, `AbstractFloat` and `nothing`. + +# Returns +- A `String` holding the canonical JSON text (2-space indentation, object keys + sorted lexicographically by `isless` on the key strings). + +# Notes +Floats are printed with `Base.print`, which emits the shortest decimal literal +that round-trips through `parse(Float64, ·)`. Reading the emitted text back +with `JSON.parsefile` therefore reproduces the original `Float64` bit pattern, +which is what lets the two engines hash and compare the same artifact. + +Non-finite floats are rejected: JSON has no representation for them, and a +silently emitted `NaN` token would be unparseable by a conforming reader. +""" +function canonical_json(value) + io = IOBuffer() + _canonical_json!(io, value, 0) + return String(take!(io)) +end + +# Recursive canonical writer. `depth` is the current indentation level; the +# emitter never depends on the container's iteration order. +function _canonical_json!(io::IO, value, depth::Int) + pad = " "^depth + pad_in = " "^(depth + 1) + if value === nothing + print(io, "null") + elseif value isa Bool + # Checked before Integer: `Bool <: Integer` in Julia. + print(io, value ? "true" : "false") + elseif value isa Integer + print(io, string(value)) + elseif value isa AbstractFloat + isfinite(value) || error("canonical_json: non-finite float $value has no JSON representation") + # Shortest round-tripping decimal; `1.0` stays `1.0` (never `1`), which + # keeps the emitted type distinguishable from an integer on re-read. + print(io, string(Float64(value))) + elseif value isa AbstractString + _canonical_json_string!(io, value) + elseif value isa AbstractDict + isempty(value) && return print(io, "{}") + # Stringify the keys once, then sort: sorting is what makes the bytes + # order-independent, and going through the pair list avoids re-indexing + # the source dictionary with a converted key. + pairs = sort!([(string(k), v) for (k, v) in value]; by = first) + allunique(first.(pairs)) || + error("canonical_json: dictionary has keys that collide once stringified") + print(io, "{\n") + for (i, (k, v)) in enumerate(pairs) + print(io, pad_in) + _canonical_json_string!(io, k) + print(io, ": ") + _canonical_json!(io, v, depth + 1) + print(io, i == length(pairs) ? "\n" : ",\n") + end + print(io, pad, "}") + elseif value isa AbstractVector + isempty(value) && return print(io, "[]") + print(io, "[\n") + for (i, v) in enumerate(value) + print(io, pad_in) + _canonical_json!(io, v, depth + 1) + print(io, i == length(value) ? "\n" : ",\n") + end + print(io, pad, "]") + else + error("canonical_json: unsupported value of type $(typeof(value))") + end + return nothing +end + +# Minimal RFC 8259 string escaping. +function _canonical_json_string!(io::IO, s::AbstractString) + print(io, '"') + for c in s + if c == '"' + print(io, "\\\"") + elseif c == '\\' + print(io, "\\\\") + elseif c == '\n' + print(io, "\\n") + elseif c == '\r' + print(io, "\\r") + elseif c == '\t' + print(io, "\\t") + elseif c < ' ' + print(io, "\\u", lpad(string(UInt16(c); base = 16), 4, '0')) + else + print(io, c) + end + end + print(io, '"') + return nothing +end + +""" + write_canonical_json(path, value) -> String + +Write `canonical_json(value)` to `path` and return the SHA-256 of the bytes +actually written. + +# Arguments +- `path::AbstractString`: destination file. +- `value`: object accepted by [`canonical_json`](@ref). + +# Returns +- Lowercase hexadecimal SHA-256 digest of the file contents. +""" +function write_canonical_json(path::AbstractString, value) + text = canonical_json(value) + mkpath(dirname(path)) + write(path, text) + return bytes2hex(sha256(text)) +end + +""" + sha256_file(path) -> String + +Lowercase hexadecimal SHA-256 digest of the bytes of `path`. +""" +sha256_file(path::AbstractString) = bytes2hex(sha256(read(path))) + +""" + plain(value) + +Recursively rebuild a parsed-JSON tree out of plain `Dict{String,Any}`, +`Vector{Any}` and scalars. + +# Notes +JSON parsers return their own container types (`JSON.Object`, lazily-typed +arrays). Those satisfy the `AbstractDict`/`AbstractVector` interfaces but not the +CONCRETE types that downstream modelling packages assume when they build typed +lookup tables from a network dictionary, which surfaces as a `convert` error +deep inside a library rather than as a data problem. Normalizing once, at the +boundary where the case is read, keeps that class of failure out of every +consumer. +""" +function plain(value) + if value isa AbstractDict + return Dict{String,Any}(string(k) => plain(v) for (k, v) in value) + elseif value isa AbstractString + return String(value) + elseif value isa AbstractVector + return Any[plain(v) for v in value] + else + return value + end +end + +# ───────────────────────────────────────────────────────────────────────────── +# Battery parameters +# ───────────────────────────────────────────────────────────────────────────── + +""" + BatterySpec + +Parameters of one battery, in the per-unit system of the host network. + +# Fields +- `index::Int`: battery identifier. Identifiers are arbitrary positive integers + and need not be consecutive; every engine keys on this value. +- `bus::Int`: identifier of the bus the battery injects into. Again an + arbitrary network identifier, never a positional index. +- `energy_min::Float64`, `energy_max::Float64`: energy bounds ``\\underline e_b`` + and ``\\overline e_b`` in per-unit-hours (pu·h), i.e. per-unit power sustained + for one hour. +- `energy_initial::Float64`: ``e_{b,0}``, the energy carried into stage 1 (pu·h). +- `charge_max::Float64`, `discharge_max::Float64`: ``\\overline p^{ch}_b`` and + ``\\overline p^{dis}_b`` in per-unit power (pu). +- `charge_efficiency::Float64`, `discharge_efficiency::Float64`: + ``\\eta^{ch}_b, \\eta^{dis}_b \\in (0,1]``. +- `self_discharge::Float64`: ``\\alpha_b \\in (0,1]``, the fraction of stored + energy retained across one stage. +- `throughput_cost::Float64`: ``c^{deg}_b``, the degradation price charged on + ``\\Delta t\\,(p^{ch}+p^{dis})``, in objective units per pu·h. + +# Notes +The state transition these fields parameterize is + +```math +e_{b,t} = \\alpha_b e_{b,t-1} + + \\eta^{ch}_b \\Delta t\\, p^{ch}_{b,t} + - \\frac{\\Delta t}{\\eta^{dis}_b} p^{dis}_{b,t}, +``` + +with ``e_{b,t}`` the END-of-stage energy. That convention is fixed here and is +never re-stated with a different meaning anywhere in either engine. +""" +struct BatterySpec + index::Int + bus::Int + energy_min::Float64 + energy_max::Float64 + energy_initial::Float64 + charge_max::Float64 + discharge_max::Float64 + charge_efficiency::Float64 + discharge_efficiency::Float64 + self_discharge::Float64 + throughput_cost::Float64 +end + +""" + reachable_interval(b::BatterySpec, e_prev, Δt) -> (lower, upper) + +One-stage battery-dynamic reachable interval for the outgoing energy. + +# Arguments +- `b::BatterySpec`: battery parameters. +- `e_prev::Real`: incoming energy ``e_{b,t-1}`` (pu·h). +- `Δt::Real`: stage duration in hours. + +# Returns +- `(lower, upper)`: the closed interval + +```math +\\underline r = \\max\\{\\underline e_b,\\; + \\alpha_b e_{t-1} - \\tfrac{\\Delta t}{\\eta^{dis}_b}\\overline p^{dis}_b\\}, +\\qquad +\\overline r = \\min\\{\\overline e_b,\\; + \\alpha_b e_{t-1} + \\eta^{ch}_b \\Delta t\\, \\overline p^{ch}_b\\}. +``` + +# Notes +Every value in `[lower, upper]` is attained by an admissible +``(p^{ch}, p^{dis})`` pair, because the transition is affine and monotone in +each control and the controls' own boxes are intervals containing 0. This is +the map the strict policy squashes its normalized output into; note that BOTH +endpoints depend on `e_prev` with slope ``\\alpha_b`` wherever the energy bound +is not the binding term, which is why a policy that differentiates through this +map must not treat the endpoints as constants. + +The returned interval is nonempty whenever ``\\underline e_b \\le \\alpha_b +e_{t-1} + \\eta^{ch}\\Delta t \\overline p^{ch}`` and ``\\alpha_b e_{t-1} - +\\Delta t \\overline p^{dis}/\\eta^{dis} \\le \\overline e_b``; with +``\\alpha_b = 1`` and ``e_{t-1} \\in [\\underline e_b, \\overline e_b]`` both +hold, so the interval is nonempty by induction along any trajectory the policy +itself generates. +""" +function reachable_interval(b::BatterySpec, e_prev::Real, Δt::Real) + decayed = b.self_discharge * e_prev + lower = max(b.energy_min, decayed - (Δt / b.discharge_efficiency) * b.discharge_max) + upper = min(b.energy_max, decayed + b.charge_efficiency * Δt * b.charge_max) + return lower, upper +end + +""" + dispatch_for_target(b::BatterySpec, e_prev, e_target, Δt) -> (p_ch, p_dis) + +The charge/discharge pair that realizes `e_target` from `e_prev` in one stage. + +# Arguments +- `b::BatterySpec`, `e_prev::Real`, `e_target::Real`, `Δt::Real`. + +# Returns +- `(p_ch, p_dis)`: nonnegative powers (pu) satisfying the state transition + exactly, with at most one of them nonzero. + +# Notes +Writing ``\\delta := e_{target} - \\alpha_b e_{prev}``, the transition +``\\delta = \\eta^{ch}\\Delta t\\,p^{ch} - (\\Delta t/\\eta^{dis})p^{dis}`` +is solved by + +```math +p^{ch} = \\frac{\\max(\\delta, 0)}{\\eta^{ch}\\Delta t}, +\\qquad +p^{dis} = \\frac{\\eta^{dis}\\max(-\\delta, 0)}{\\Delta t}. +``` + +This is the unique solution with `p_ch * p_dis == 0`; it is admissible exactly +when `e_target` lies in [`reachable_interval`](@ref). It is used to CERTIFY +recourse (given a reachable target, exhibit the controls that hit it) and never +to replace an optimizer's choice inside a stage problem. +""" +function dispatch_for_target(b::BatterySpec, e_prev::Real, e_target::Real, Δt::Real) + δ = e_target - b.self_discharge * e_prev + p_ch = max(δ, 0.0) / (b.charge_efficiency * Δt) + p_dis = b.discharge_efficiency * max(-δ, 0.0) / Δt + return p_ch, p_dis +end + +""" + battery_injection(b::BatterySpec, p_ch, p_dis) -> Float64 + +Active power injected into the network, ``p^{bat} = p^{dis} - p^{ch}`` (pu). + +# Notes +The battery operates at unity power factor: ``q^{bat} \\equiv 0``. Discharging +is a positive injection; charging is a negative one. +""" +battery_injection(::BatterySpec, p_ch::Real, p_dis::Real) = float(p_dis - p_ch) + +""" + RecourseCosts + +Prices of the two-sided physical active-power recourse, in objective units per +pu per stage. + +# Fields +- `deficit::Float64`: ``C^{def}``, price of the nonnegative uncapped injection + ``d_{i,t}`` (unserved load, or the active power a charging target needs and + the grid cannot deliver). +- `surplus::Float64`: ``C^{sur}``, price of the nonnegative uncapped sink + ``s_{i,t}`` (active power a discharging target produces and the grid cannot + absorb). + +# Notes +Both prices must sit far above the most expensive generator so that recourse is +never an economic substitute for dispatch; both must be IDENTICAL in the +PowerModels ACP model, the PowerModels SOC-WR model, the Exa ACP model, and in +both SDDP passes. They travel in the frozen case artifact for exactly that +reason: neither engine gets to choose them. + +`d` and `s` are physical operating recourse, not target slack. They appear only +in the nodal ACTIVE balance; they appear in no battery state equation and in no +strict target equality, and there is no target-slack variable anywhere in the +supported formulation. +""" +struct RecourseCosts + deficit::Float64 + surplus::Float64 +end + +# ───────────────────────────────────────────────────────────────────────────── +# The frozen finite demand support +# +# Demand is the study's ONLY uncertainty. For the original PGLib load values +# p^{d,0}_i and q^{d,0}_i, the realized demand of load i at stage t under atom k +# is +# +# p^d_{i,t,k} = h_{i,t} m^{(k)}_{i,t} p^{d,0}_i +# q^d_{i,t,k} = h_{i,t} m^{(k)}_{i,t} q^{d,0}_i +# +# with h a DETERMINISTIC temporal profile and m the uncertain multiplier. The +# SAME multiplier scales the active and the reactive demand, so every +# realization has the case's own power factor: the uncertainty moves how much +# power is consumed, never what kind. +# +# The multiplier is a JOINT VECTOR over loads, not a scalar and not a collection +# of independent draws — an independent-per-load sampler is one way to produce +# such a vector, never the representation itself. +# ───────────────────────────────────────────────────────────────────────────── + +""" + DemandSupport + +The frozen, stage-major finite support of the demand process. + +# Fields +- `stage_hours::Float64`: ``\\Delta t``, the duration of one stage in hours. +- `horizon::Int`: number of stages the support is frozen for. Stage indices + outside `1:horizon` are an error, never silently wrapped. +- `load_ids::Vector{Int}`: LOAD identifiers, sorted ascending. This vector fixes + the order of every multiplier and profile row and is the only definition of + "component `j`" in this artifact. +- `profile::Matrix{Float64}`: ``h_{i,t}``, size `(length(load_ids), horizon)`, + the deterministic temporal profile. +- `atoms::Vector{Matrix{Float64}}`: `atoms[t]` has size + `(length(load_ids), K_t)`; column `k` is the joint multiplier vector + ``m^{(k)}_{\\cdot,t}``. +- `probabilities::Vector{Vector{Float64}}`: `probabilities[t]` has length + `K_t` and sums to 1. +- `protocol_seed::Int`: seed of the `StableRNG` that generates evaluation + scenario index matrices. +- `source::Dict{String,Any}`: a description of the AUTHORING sampler and of the + discretization that produced these atoms. Documentation, not data: nothing + reads it to build a model. It exists so a frozen support can be traced back to + the sampler it came from. + +# Notes +The support is stage-dependent by construction (`K_t` may differ across stages) +and stagewise independent: an atom index at stage `t` carries no information +about stage `t+1`. That is what both SDDP's backward enumeration and TS-DDR's +trajectory sampling assume, and it is enforced by the representation rather than +by a comment. +""" +struct DemandSupport + stage_hours::Float64 + horizon::Int + load_ids::Vector{Int} + profile::Matrix{Float64} + atoms::Vector{Matrix{Float64}} + probabilities::Vector{Vector{Float64}} + protocol_seed::Int + source::Dict{String,Any} +end + +"Number of loads the support is defined over." +num_loads(s::DemandSupport) = length(s.load_ids) + +"Number of stages the support is frozen for." +horizon(s::DemandSupport) = s.horizon + +""" + profile_period(s::DemandSupport) -> Int + +The cycle length the deterministic profile repeats on, in stages. + +# Notes +Recorded by the freezing operation and used for exactly one purpose: as the +period of the ``(\\sin, \\cos)`` clock feature a policy is given, so that the +position in the daily cycle is encoded without the discontinuity a raw stage +index would introduce at midnight. It is DETERMINISTIC information — knowing the +clock is not knowing the future demand — and it never enters a stage problem. + +Falls back to the frozen horizon when a support was written without one, which +degrades the feature to "position in the horizon" rather than silently claiming +a 24-stage cycle a case may not have. +""" +profile_period(s::DemandSupport) = Int(get(s.source, "profile_period", s.horizon)) + +""" + num_atoms(s::DemandSupport, t) -> Int + +Size ``K_t`` of the finite support at stage `t`. +""" +function num_atoms(s::DemandSupport, t::Integer) + _check_stage(s, t) + return length(s.probabilities[t]) +end + +""" + atom_probabilities(s::DemandSupport, t) -> Vector{Float64} + +The probabilities ``(p_{t,1},\\ldots,p_{t,K_t})`` of stage `t`'s atoms. +""" +function atom_probabilities(s::DemandSupport, t::Integer) + _check_stage(s, t) + return s.probabilities[t] +end + +""" + demand_multipliers(s::DemandSupport, t, atom) -> Vector{Float64} + +The TOTAL per-load multiplier ``h_{i,t}\\,m^{(atom)}_{i,t}`` at stage `t`, in +`load_ids` order. + +# Notes +This is the only place the deterministic profile and the uncertain multiplier are +combined, so the two can never be applied twice or in the wrong order anywhere +downstream. +""" +function demand_multipliers(s::DemandSupport, t::Integer, atom::Integer) + _check_stage(s, t) + K = num_atoms(s, t) + 1 <= atom <= K || + throw(ArgumentError("atom index $atom outside 1:$K at stage $t")) + return @views s.profile[:, t] .* s.atoms[t][:, atom] +end + +# Fail closed on a stage index outside the frozen window. Silently wrapping (as +# a cyclic profile would) is how a horizon change becomes an undetected change +# of problem. +function _check_stage(s::DemandSupport, t::Integer) + 1 <= t <= s.horizon || + throw(ArgumentError("stage $t outside the frozen horizon 1:$(s.horizon)")) + return nothing +end + +""" + support_digest(s::DemandSupport) -> String + +SHA-256 of the frozen support, in a fixed textual encoding. + +# Notes +This digest is what makes "SDDP and TS-DDR consumed the same demand support" a +verifiable claim: both engines recompute it from the bytes they loaded and it is +recorded in the manifest. It covers the stage duration, the horizon, the load +order, the profile, every atom and every probability — that is, everything a +stage problem's demand depends on — and deliberately NOT the `source` +description, which is prose about how the atoms were authored and must not be +able to change the identity of a support. +""" +function support_digest(s::DemandSupport) + io = IOBuffer() + println(io, "battery_storage_opf/support/2") + println(io, s.stage_hours, " ", s.horizon, " ", num_loads(s), " ", s.protocol_seed) + println(io, join(s.load_ids, ",")) + for t in 1:s.horizon + println(io, "t", t, " ", num_atoms(s, t)) + println(io, join((string(x) for x in @views s.profile[:, t]), ",")) + for k in 1:num_atoms(s, t) + println(io, string(s.probabilities[t][k]), " ", + join((string(x) for x in @views s.atoms[t][:, k]), ",")) + end + end + return bytes2hex(sha256(take!(io))) +end + +""" + scenario_index_matrix(s::DemandSupport, num_stages, num_scenarios; seed=nothing) + -> Matrix{Int} + +A paired evaluation protocol, reproduced by construction rather than stored. + +# Arguments +- `s::DemandSupport`: supplies the default seed and the per-stage support sizes. +- `num_stages::Integer`, `num_scenarios::Integer`: shape of the protocol. + +# Keywords +- `seed`: `nothing` for the support's own `protocol_seed` — which is the FINAL + protocol's seed — or another integer for an INDEPENDENT protocol. A study needs + at least two: a small screening protocol it may look at while choosing a case + and selecting checkpoints, and a final one no policy was ever selected on. + Taking the screening set as a prefix of the final one would make the final + protocol not fresh, which is the whole property it exists to have. + +# Returns +- `Matrix{Int}` of size `(num_stages, num_scenarios)`; entry `[t, s]` is the + atom index realized at stage `t` of paired column `s`. + +# Notes +Drawn from `StableRNG(protocol_seed)`, whose stream is fixed across Julia +versions and platforms, so both engines regenerate the identical matrix and only +its SHA-256 needs to be recorded in the manifest. Scenario columns are global +and immutable: column `s` means the same demand path to every policy and to +every shard of an evaluation. + +Draw ORDER is stage-major (all scenarios of stage 1, then all of stage 2, …). +Because each stage's support size ``K_t`` may differ, a scenario-major order +would make the stream position depend on the horizon; stage-major keeps a +protocol of `num_scenarios` columns a prefix of a protocol of more columns only +within a stage, which is the property shard boundaries rely on. +""" +function scenario_index_matrix(s::DemandSupport, num_stages::Integer, num_scenarios::Integer; + seed = nothing) + num_stages >= 1 || throw(ArgumentError("num_stages must be positive")) + num_scenarios >= 1 || throw(ArgumentError("num_scenarios must be positive")) + num_stages <= s.horizon || + throw(ArgumentError("protocol asks for $num_stages stages but the support is frozen for $(s.horizon)")) + rng = StableRNG(seed === nothing ? s.protocol_seed : Int(seed)) + m = Matrix{Int}(undef, num_stages, num_scenarios) + for t in 1:num_stages + K = num_atoms(s, t) + for c in 1:num_scenarios + m[t, c] = rand(rng, 1:K) + end + end + return m +end + +""" + protocol_digest(s::DemandSupport, num_stages, num_scenarios; seed=nothing) -> String + +SHA-256 of the protocol index matrix, in a fixed textual encoding. + +# Notes +The digest, not the matrix, is what the manifest stores. Both engines recompute +the matrix from the seed and must obtain this digest; a mismatch means the two +engines are not evaluating the same scenarios and no comparison between them is +meaningful. +""" +function protocol_digest(s::DemandSupport, num_stages::Integer, num_scenarios::Integer; + seed = nothing) + m = scenario_index_matrix(s, num_stages, num_scenarios; seed = seed) + io = IOBuffer() + println(io, "battery_storage_opf/protocol/2") + println(io, num_stages, " ", num_scenarios, " ", + seed === nothing ? s.protocol_seed : Int(seed)) + println(io, join((num_atoms(s, t) for t in 1:num_stages), ",")) + for t in 1:num_stages + println(io, join(view(m, t, :), ",")) + end + return bytes2hex(sha256(take!(io))) +end + +""" + validate_support(s::DemandSupport) -> Nothing + +Fail closed on every property the rest of the study assumes of a frozen support. + +# Notes +Each check corresponds to a way two engines could end up solving different +problems while both reporting success: a probability vector that does not +normalize silently reweights an SDDP backward pass; a negative or non-finite +multiplier produces a load the network was never meant to serve; a load order +that is not sorted-unique makes "component `j`" mean two different things in two +engines. +""" +function validate_support(s::DemandSupport) + s.stage_hours > 0 || error("stage_hours must be positive, got $(s.stage_hours)") + s.horizon >= 1 || error("horizon must be at least 1, got $(s.horizon)") + n = num_loads(s) + n >= 1 || error("a demand support must cover at least one load") + issorted(s.load_ids) && allunique(s.load_ids) || + error("load_ids must be sorted and unique; got $(s.load_ids)") + size(s.profile) == (n, s.horizon) || + error("profile must be $(n)×$(s.horizon), got $(size(s.profile))") + all(isfinite, s.profile) || error("profile has a non-finite entry") + all(>=(0), s.profile) || error("profile has a negative entry") + length(s.atoms) == s.horizon || + error("support has $(length(s.atoms)) stages of atoms but horizon $(s.horizon)") + length(s.probabilities) == s.horizon || + error("support has $(length(s.probabilities)) stages of probabilities but horizon $(s.horizon)") + for t in 1:s.horizon + A = s.atoms[t] + p = s.probabilities[t] + size(A, 1) == n || + error("stage $t atoms have $(size(A, 1)) rows but the support covers $n loads") + size(A, 2) == length(p) || + error("stage $t has $(size(A, 2)) atoms but $(length(p)) probabilities") + length(p) >= 1 || error("stage $t has an empty support") + all(isfinite, A) || error("stage $t has a non-finite multiplier") + all(>=(0), A) || error("stage $t has a negative multiplier") + all(>(0), p) || error("stage $t has a non-positive probability") + isapprox(sum(p), 1.0; atol = 1e-12) || + error("stage $t probabilities sum to $(sum(p)), not 1") + end + return nothing +end + +# ───────────────────────────────────────────────────────────────────────────── +# Battery placement +# +# Placement is authoring-side, but it lives here because the manifest must be +# able to record exactly how a fleet was chosen, and because the eligibility and +# validity rules are properties of the case contract rather than of a script. +# ───────────────────────────────────────────────────────────────────────────── + +""" + PlacementStrategy + +How the buses hosting batteries are chosen. Concrete strategies: +[`ExplicitPlacement`](@ref), [`SampledPlacement`](@ref), +[`CallablePlacement`](@ref). + +# Notes +Every strategy returns bus IDENTIFIERS, never positions, and every strategy is +reproducible from the data recorded in the manifest alone. +""" +abstract type PlacementStrategy end + +""" + ExplicitPlacement(buses) + +Place batteries at the given bus identifiers, in ascending order. + +# Notes +`count` is not consulted: the list IS the fleet size. Duplicates are rejected +rather than deduplicated, because a repeated identifier is far more likely to be +a typo than a request for two batteries at one bus (which is expressed by giving +two `BatterySpec`s at the same bus instead). +""" +struct ExplicitPlacement <: PlacementStrategy + buses::Vector{Int} +end + +ExplicitPlacement(buses) = ExplicitPlacement(sort!(collect(Int.(buses)))) + +""" + SampledPlacement(count; seed, weight=nothing) + +Draw `count` distinct eligible buses without replacement. + +# Fields +- `count::Int`: fleet size. +- `seed::Int`: seed of the `StableRNG` driving the draw. +- `weight`: `nothing` for a uniform draw, or a callable `bus -> Float64` + returning a nonnegative sampling weight (e.g. nominal demand at the bus). + +# Notes +Without replacement means a bus drawn once is removed from the pool, so a +weighted draw is a successive-sampling scheme rather than `count` independent +draws. The candidate pool is SORTED before the first draw, which is what makes +the result independent of dictionary iteration order. +""" +struct SampledPlacement <: PlacementStrategy + count::Int + seed::Int + weight::Any +end + +SampledPlacement(count::Integer; seed::Integer, weight = nothing) = + SampledPlacement(Int(count), Int(seed), weight) + +""" + CallablePlacement(f; name="callable") + +Place batteries at `f(candidates, meta)`, where `candidates` is the sorted vector +of eligible bus identifiers and `meta` is the placement metadata named tuple. + +# Notes +The escape hatch for a placement rule the study does not anticipate — a +graph-theoretic centrality, an optimization, a hand-drawn map. Whatever it +returns is validated exactly as any other strategy's output, and `name` is what +the manifest records in place of a rule it cannot serialize. +""" +struct CallablePlacement <: PlacementStrategy + f::Any + name::String +end + +CallablePlacement(f; name::AbstractString = "callable") = CallablePlacement(f, String(name)) + +""" + load_buses(network) -> Vector{Int} + +Sorted identifiers of buses hosting at least one in-service load. + +# Notes +The default eligible set. A battery at a bus that neither consumes nor generates +is a pure network-support device, which is a different study; restricting to load +buses keeps a randomly placed fleet physically interpretable on any PGLib case. +""" +function load_buses(network::AbstractDict) + out = Set{Int}() + for (_, load) in network["load"] + Int(get(load, "status", 1)) == 0 && continue + push!(out, Int(load["load_bus"])) + end + return sort!(collect(out)) +end + +""" + nominal_load_at_bus(network) -> Dict{Int,Float64} + +Nominal in-service active demand aggregated per bus identifier (pu). +""" +function nominal_load_at_bus(network::AbstractDict) + out = Dict{Int,Float64}() + for (_, load) in network["load"] + Int(get(load, "status", 1)) == 0 && continue + bus = Int(load["load_bus"]) + out[bus] = get(out, bus, 0.0) + Float64(load["pd"]) + end + return out +end + +""" + eligible_buses(network; eligible=nothing) -> Vector{Int} + +The sorted candidate set a sampling placement draws from. + +# Keywords +- `eligible`: `nothing` for the default (in-service load buses), an iterable of + bus identifiers, or a predicate `bus_dict -> Bool` applied to each bus entry of + the network. + +# Notes +Whatever the source, the returned buses are checked to exist, to be in service +and to be connected — a bus with no incident in-service branch cannot host a +battery that participates in the study, and PGLib cases do contain isolated +buses. +""" +function eligible_buses(network::AbstractDict; eligible = nothing) + ids = Set(Int(b["index"]) for (_, b) in network["bus"]) + candidates = if eligible === nothing + load_buses(network) + elseif eligible isa Function + sort!([Int(b["index"]) for (_, b) in network["bus"] if eligible(b)]) + else + sort!(collect(Int.(eligible))) + end + allunique(candidates) || error("eligible bus set contains duplicates") + in_service = Set(Int(b["index"]) for (_, b) in network["bus"] + if Int(get(b, "bus_type", 1)) != 4) + connected = Set{Int}() + for (_, br) in network["branch"] + Int(get(br, "br_status", 1)) == 0 && continue + push!(connected, Int(br["f_bus"])) + push!(connected, Int(br["t_bus"])) + end + for b in candidates + b in ids || error("bus $b is not in the network") + b in in_service || error("bus $b is out of service (bus_type 4)") + b in connected || error("bus $b has no in-service branch and is disconnected") + end + isempty(candidates) && error("no eligible bus remains after filtering") + return candidates +end + +""" + select_battery_buses(network, strategy; eligible=nothing) -> (buses, record) + +Apply a [`PlacementStrategy`](@ref) and return both the chosen buses and the +manifest record describing how they were chosen. + +# Returns +- `buses::Vector{Int}`: sorted, distinct, validated bus identifiers. +- `record::Dict{String,Any}`: strategy name, seed, eligible set, weights and the + selection, in a form the manifest can serialize verbatim. + +# Notes +The eligible set is recorded in FULL, not summarized. "Three buses were drawn +from the load buses" is not reproducible if a later revision of the case adds a +load; the actual pool that was drawn from is. +""" +function select_battery_buses(network::AbstractDict, strategy::PlacementStrategy; + eligible = nothing) + candidates = eligible_buses(network; eligible = eligible) + record = Dict{String,Any}("eligible" => candidates) + + buses = if strategy isa ExplicitPlacement + allunique(strategy.buses) || error("explicit battery buses must be distinct") + for b in strategy.buses + b in candidates || + error("explicit battery bus $b is not in the eligible set") + end + record["strategy"] = "explicit" + copy(strategy.buses) + + elseif strategy isa SampledPlacement + strategy.count >= 1 || throw(ArgumentError("count must be at least 1")) + strategy.count <= length(candidates) || + throw(ArgumentError("cannot place $(strategy.count) batteries on $(length(candidates)) eligible buses")) + rng = StableRNG(strategy.seed) + weights = strategy.weight === nothing ? + fill(1.0, length(candidates)) : + [Float64(strategy.weight(b)) for b in candidates] + all(isfinite, weights) || error("placement weights must be finite") + all(>=(0), weights) || error("placement weights must be nonnegative") + record["strategy"] = strategy.weight === nothing ? "uniform" : "weighted" + record["seed"] = strategy.seed + record["weights"] = weights + sort!(_sample_without_replacement(rng, candidates, weights, strategy.count)) + + elseif strategy isa CallablePlacement + chosen = sort!(collect(Int.(strategy.f(candidates, (network = network, + candidates = candidates))))) + allunique(chosen) || error("callable placement returned duplicate buses") + for b in chosen + b in candidates || error("callable placement returned ineligible bus $b") + end + record["strategy"] = "callable:" * strategy.name + chosen + + else + error("unsupported placement strategy $(typeof(strategy))") + end + + isempty(buses) && error("placement selected no bus") + record["selected"] = buses + return buses, record +end + +""" + _sample_without_replacement(rng, items, weights, count) -> Vector + +Successive weighted sampling without replacement. + +# Notes +At each of `count` rounds the remaining items are sampled with probability +proportional to their weight and the chosen item is removed. With all weights +equal this reduces to a uniform draw without replacement. The implementation +consumes the stream through `rand(rng)` only, so the result depends on the seed +and not on any `Random` API whose behaviour is free to change between Julia +versions. +""" +function _sample_without_replacement(rng, items::AbstractVector, weights::AbstractVector, + count::Integer) + pool = collect(items) + w = collect(Float64.(weights)) + out = eltype(items)[] + for _ in 1:count + total = sum(w) + total > 0 || error("placement weights of the remaining pool sum to zero") + u = rand(rng) * total + acc = 0.0 + j = length(w) + for i in eachindex(w) + acc += w[i] + if u <= acc + j = i + break + end + end + push!(out, pool[j]) + deleteat!(pool, j) + deleteat!(w, j) + end + return out +end + +""" + battery_fleet(network, buses; power, energy_hours, charge_efficiency, + discharge_efficiency, self_discharge, throughput_cost, + initial_fraction) -> (Vector{BatterySpec}, record) + +Give the selected buses their ratings. + +# Arguments +- `buses::AbstractVector{Int}`: the output of [`select_battery_buses`](@ref). + +# Keywords +- `power`: the power rating rule. Either a `Real` in pu applied to every + battery, a `Dict{Int,<:Real}` keyed by bus, or a callable `bus -> Real`. A + callable closing over a `Distribution` and an RNG is how a SAMPLED capacity is + expressed without this file depending on Distributions.jl. +- `energy_hours`: energy rating as hours at full discharge power; same three + forms as `power`. +- `charge_efficiency`, `discharge_efficiency`, `self_discharge`, + `throughput_cost`, `initial_fraction`: same three forms; scalars in practice. +- `reserve_fraction`: the OPERATING BAND. `energy_min = reserve_fraction * + energy_max` and `energy_max` is unchanged, so a nonzero value keeps the battery + off the exact bottom of its box. Physically it is the reserve a real battery is + not allowed to discharge below; numerically it matters more than it sounds, + because at an exact box corner the one-stage reachable interval collapses + against a bound, the transition equality and the energy bound become parallel, + and the resulting near-degenerate face is what defeats a conic interior-point + method on the SOC-WR relaxation. + +# Returns +- The fleet sorted by battery index, and the manifest record of the capacity rule. + +# Notes +Batteries are indexed `1:n` in the order of the (sorted) bus identifiers. Battery +INDEX is an identity, not a position — every engine keys on it — but assigning +them consecutively at construction keeps the frozen artifact readable. + +Every parameter is validated here rather than at read time as well, so a case +that cannot be built is rejected where the rule that produced it is still in +scope. +""" +function battery_fleet(network::AbstractDict, buses::AbstractVector{<:Integer}; + power, + energy_hours, + charge_efficiency = 0.95, + discharge_efficiency = 0.95, + self_discharge = 1.0, + throughput_cost = 0.0, + initial_fraction = 0.5, + reserve_fraction = 0.0) + resolve(rule, bus) = rule isa Function ? Float64(rule(bus)) : + rule isa AbstractDict ? Float64(rule[bus]) : Float64(rule) + + specs = BatterySpec[] + record = Dict{String,Any}("power_pu" => Dict{String,Any}(), + "energy_hours" => Dict{String,Any}()) + for (i, bus) in enumerate(buses) + p = resolve(power, bus) + h = resolve(energy_hours, bus) + ηc = resolve(charge_efficiency, bus) + ηd = resolve(discharge_efficiency, bus) + α = resolve(self_discharge, bus) + c = resolve(throughput_cost, bus) + f0 = resolve(initial_fraction, bus) + rf = resolve(reserve_fraction, bus) + + p > 0 || error("battery at bus $bus: power rating must be positive, got $p") + h > 0 || error("battery at bus $bus: energy duration must be positive, got $h") + 0 < ηc <= 1 || error("battery at bus $bus: charge_efficiency out of (0,1]") + 0 < ηd <= 1 || error("battery at bus $bus: discharge_efficiency out of (0,1]") + 0 < α <= 1 || error("battery at bus $bus: self_discharge out of (0,1]") + c >= 0 || error("battery at bus $bus: throughput_cost must be nonnegative") + 0 <= f0 <= 1 || error("battery at bus $bus: initial_fraction out of [0,1]") + 0 <= rf < 1 || error("battery at bus $bus: reserve_fraction out of [0,1)") + rf <= f0 || error("battery at bus $bus: initial_fraction $f0 is below the reserve $rf") + + e_max = h * p + push!(specs, BatterySpec(i, Int(bus), rf * e_max, e_max, f0 * e_max, p, p, + ηc, ηd, α, c)) + record["power_pu"][string(bus)] = p + record["reserve_fraction"] = rf + record["energy_hours"][string(bus)] = h + end + return specs, record +end + +# ───────────────────────────────────────────────────────────────────────────── +# Case container and I/O +# ───────────────────────────────────────────────────────────────────────────── + +""" + BatteryCase + +Everything both engines need in order to build the same stage problem. + +# Fields +- `dir::String`: directory the artifacts were read from. +- `name::String`: PGLib case name, e.g. `"pglib_opf_case14_ieee"`. +- `network::Dict{String,Any}`: the parsed PGLib network, per-unit, verbatim. +- `batteries::Vector{BatterySpec}`: sorted by battery index. +- `recourse::RecourseCosts`: prices of the two-sided nodal active recourse. +- `demand::DemandSupport`: the frozen finite demand support. +- `manifest::Dict{String,Any}`: the manifest as read from disk. +""" +struct BatteryCase + dir::String + name::String + network::Dict{String,Any} + batteries::Vector{BatterySpec} + recourse::RecourseCosts + demand::DemandSupport + manifest::Dict{String,Any} +end + +"Stage duration ``\\Delta t`` in hours." +stage_hours(c::BatteryCase) = c.demand.stage_hours + +""" + nominal_load_demand(case) -> (pd::Vector{Float64}, qd::Vector{Float64}) + +Nominal active and reactive demand of every load in `case.demand.load_ids` +order (pu). + +# Notes +The support's load order — not the network dictionary's iteration order — is what +indexes every multiplier vector, so it is what indexes the nominal values too. +""" +function nominal_load_demand(case::BatteryCase) + by_id = Dict{Int,Any}(Int(l["index"]) => l for (_, l) in case.network["load"]) + pd = Vector{Float64}(undef, num_loads(case.demand)) + qd = Vector{Float64}(undef, num_loads(case.demand)) + for (j, id) in enumerate(case.demand.load_ids) + load = by_id[id] + pd[j] = Float64(load["pd"]) + qd[j] = Float64(load["qd"]) + end + return pd, qd +end + +""" + nominal_bus_demand(case) -> (pd::Dict{Int,Float64}, qd::Dict{Int,Float64}) + +Nominal active and reactive demand aggregated per BUS identifier (pu). + +# Notes +A bus may host several loads; the network's nodal balance constrains only their +sum, so both engines aggregate to the bus before anything else happens. Buses +with no load appear with an explicit `0.0` so downstream code can index every +bus without a `get` default and its attendant typo risk. +""" +function nominal_bus_demand(case::BatteryCase) + pd = Dict{Int,Float64}(Int(b["index"]) => 0.0 for (_, b) in case.network["bus"]) + qd = Dict{Int,Float64}(Int(b["index"]) => 0.0 for (_, b) in case.network["bus"]) + for (_, load) in case.network["load"] + Int(get(load, "status", 1)) == 0 && continue + bus = Int(load["load_bus"]) + pd[bus] += Float64(load["pd"]) + qd[bus] += Float64(load["qd"]) + end + return pd, qd +end + +""" + realized_bus_demand(case, t, atom) -> (pd::Dict{Int,Float64}, qd::Dict{Int,Float64}) + +Per-bus demand realized at stage `t` under atom index `atom` (pu). + +# Notes +Each load is scaled by its own total multiplier +``h_{i,t} m^{(atom)}_{i,t}`` and the scaled loads are then aggregated to their +bus. The same multiplier scales active and reactive demand, so the power factor +of every individual load is preserved exactly — which is a stronger statement +than preserving the aggregate power factor at the bus, and is the one the study +claims. + +Loads that are out of service contribute nothing, and buses with no load appear +with `0.0`, so the returned dictionaries cover every bus of the network. +""" +function realized_bus_demand(case::BatteryCase, t::Integer, atom::Integer) + pd = Dict{Int,Float64}(Int(b["index"]) => 0.0 for (_, b) in case.network["bus"]) + qd = Dict{Int,Float64}(Int(b["index"]) => 0.0 for (_, b) in case.network["bus"]) + mult = demand_multipliers(case.demand, t, atom) + by_id = Dict{Int,Any}(Int(l["index"]) => l for (_, l) in case.network["load"]) + for (j, id) in enumerate(case.demand.load_ids) + load = by_id[id] + Int(get(load, "status", 1)) == 0 && continue + bus = Int(load["load_bus"]) + pd[bus] += Float64(load["pd"]) * mult[j] + qd[bus] += Float64(load["qd"]) * mult[j] + end + return pd, qd +end + +""" + demand_path(case, atoms) -> Vector{Tuple{Dict{Int,Float64},Dict{Int,Float64}}} + +Materialize a COMPLETE demand path: the per-bus `(pd, qd)` of every stage of the +atom-index vector `atoms`. + +# Notes +A "demand path" is the object a deterministic-equivalent solve and a +perfect-foresight panel consume; giving it a name here keeps every caller from +re-deriving the stage-to-atom mapping and getting the stage offset wrong. +""" +function demand_path(case::BatteryCase, atoms::AbstractVector{<:Integer}) + return [realized_bus_demand(case, t, atoms[t]) for t in eachindex(atoms)] +end + +""" + write_battery_case(dir; name, network, batteries, recourse, demand, + source_version, placement, protocol_stages, + protocol_scenarios) -> Dict{String,Any} + +Write the four frozen artifacts and return the manifest that was written. + +# Notes +The manifest is written LAST and records the SHA-256 of the three artifacts as +they landed on disk, so a manifest can never describe bytes that were never +written. Every value the two engines must agree on — stage duration, unit +conventions, component counts, the support digest, the protocol digest — is +recorded here rather than recomputed independently on each side. + +Stage duration is recorded once, in hours, and read back by +[`read_battery_case`](@ref) with a fail-closed check. This is the battery +analogue of the hydro `stage_hours`, whose omission once rescaled a whole +study's dynamics by a factor of 168. +""" +function write_battery_case(dir::AbstractString; + name::AbstractString, + network::AbstractDict, + batteries::AbstractVector{BatterySpec}, + recourse::RecourseCosts, + demand::DemandSupport, + source_version::AbstractString, + placement::AbstractDict = Dict{String,Any}(), + protocol_stages::Integer, + protocol_scenarios::Integer, + screening_seed::Union{Nothing,Integer} = nothing, + screening_scenarios::Integer = 0) + validate_support(demand) + mkpath(dir) + + network_obj = Dict{String,Any}( + "schema" => BATTERY_NETWORK_SCHEMA, + "name" => name, + "source_version" => source_version, + "data" => network, + ) + network_sha = write_canonical_json(joinpath(dir, "network.json"), network_obj) + + batteries_obj = Dict{String,Any}( + "schema" => BATTERY_BATTERY_SCHEMA, + "case" => name, + # The two-sided nodal active recourse is part of the same extension + # layer as the batteries: it is what makes a strict, dynamically + # reachable target admissible under the true network. Freezing its + # prices here is what guarantees both engines and both SDDP passes + # charge for it identically. + "recourse" => Dict{String,Any}( + "deficit_cost" => recourse.deficit, + "surplus_cost" => recourse.surplus, + ), + # How the fleet was chosen, in enough detail to redraw it. + "placement" => Dict{String,Any}(placement), + "batteries" => [Dict{String,Any}( + "index" => b.index, + "bus" => b.bus, + "energy_min" => b.energy_min, + "energy_max" => b.energy_max, + "energy_initial" => b.energy_initial, + "charge_max" => b.charge_max, + "discharge_max" => b.discharge_max, + "charge_efficiency" => b.charge_efficiency, + "discharge_efficiency" => b.discharge_efficiency, + "self_discharge" => b.self_discharge, + "throughput_cost" => b.throughput_cost, + ) for b in batteries], + ) + batteries_sha = write_canonical_json(joinpath(dir, "batteries.json"), batteries_obj) + + demand_obj = Dict{String,Any}( + "schema" => BATTERY_DEMAND_SCHEMA, + "case" => name, + "stage_hours" => demand.stage_hours, + "horizon" => demand.horizon, + "load_ids" => demand.load_ids, + # Stage-major, load-minor: `profile[t][j]` is load `load_ids[j]` at stage + # `t`. Writing it stage-major matches how a stage problem reads it. + "profile" => [Float64[demand.profile[j, t] for j in 1:num_loads(demand)] + for t in 1:demand.horizon], + "atoms" => [[Float64[demand.atoms[t][j, k] for j in 1:num_loads(demand)] + for k in 1:num_atoms(demand, t)] for t in 1:demand.horizon], + "probabilities" => [copy(demand.probabilities[t]) for t in 1:demand.horizon], + "protocol_seed" => demand.protocol_seed, + "source" => Dict{String,Any}(demand.source), + ) + demand_sha = write_canonical_json(joinpath(dir, "demand.json"), demand_obj) + + manifest = Dict{String,Any}( + "schema" => BATTERY_MANIFEST_SCHEMA, + "case" => name, + "source" => Dict{String,Any}("package" => "PGLib.jl", "version" => source_version), + "stage_hours" => demand.stage_hours, + "units" => Dict{String,Any}( + "power" => "per-unit on network baseMVA", + "energy" => "per-unit-hours (pu power sustained for one hour)", + "time" => "hours", + # Every number this study builds, solves and reports is in this one + # unit. No stage objective is rescaled on its way into a solver and + # none is converted on its way out: the model a solver sees carries + # the physical stage cost, so a reported cost, a cut and a multiplier + # are all comparable without any conversion step. + "cost" => "objective units of the PGLib case per hour", + ), + "counts" => Dict{String,Any}( + "bus" => length(network["bus"]), + "gen" => length(network["gen"]), + "branch" => length(network["branch"]), + "load" => length(network["load"]), + "shunt" => length(get(network, "shunt", Dict())), + "battery" => length(batteries), + "horizon" => demand.horizon, + "demand_atom_min" => minimum(num_atoms(demand, t) for t in 1:demand.horizon), + "demand_atom_max" => maximum(num_atoms(demand, t) for t in 1:demand.horizon), + ), + "baseMVA" => Float64(network["baseMVA"]), + "recourse" => Dict{String,Any}( + "deficit_cost" => recourse.deficit, + "surplus_cost" => recourse.surplus, + ), + "support" => Dict{String,Any}( + "sha256" => support_digest(demand), + "source" => Dict{String,Any}(demand.source), + ), + # The FINAL paired protocol. Generated from the support's own seed and + # hashed here; a phase that must not evaluate on it can still record what + # it will be. + "protocol" => Dict{String,Any}( + "seed" => demand.protocol_seed, + "num_stages" => protocol_stages, + "num_scenarios" => protocol_scenarios, + "sha256" => protocol_digest(demand, protocol_stages, protocol_scenarios), + ), + # The SCREENING protocol, drawn from an INDEPENDENT seed. Everything a + # case-selection or checkpoint-selection decision may look at comes from + # here, which is what leaves the final protocol fresh. + "screening" => screening_seed === nothing ? nothing : Dict{String,Any}( + "seed" => Int(screening_seed), + "num_stages" => protocol_stages, + "num_scenarios" => Int(screening_scenarios), + "sha256" => protocol_digest(demand, protocol_stages, Int(screening_scenarios); + seed = Int(screening_seed)), + ), + "artifacts" => Dict{String,Any}( + "network.json" => network_sha, + "batteries.json" => batteries_sha, + "demand.json" => demand_sha, + ), + ) + write_canonical_json(joinpath(dir, "case_manifest.json"), manifest) + return manifest +end + +""" + read_battery_case(dir; verify=true) -> BatteryCase + +Read a frozen case from `dir`. + +# Keywords +- `verify::Bool`: when `true` (the default) every artifact hash, schema tag, + stage duration, support digest and protocol digest recorded in the manifest is + re-checked against the bytes on disk before anything is returned. + +# Notes +Verification is on by default and failures are ERRORS, never warnings: an +engine that proceeds on a case it could not verify is producing numbers that +cannot be compared with the other engine's. +""" +function read_battery_case(dir::AbstractString; verify::Bool = true) + manifest_path = joinpath(dir, "case_manifest.json") + isfile(manifest_path) || error("no case_manifest.json in $dir") + manifest = JSON.parsefile(manifest_path) + manifest["schema"] == BATTERY_MANIFEST_SCHEMA || + error("unexpected manifest schema $(manifest["schema"]); expected $BATTERY_MANIFEST_SCHEMA") + + if verify + for (file, want) in manifest["artifacts"] + path = joinpath(dir, file) + isfile(path) || error("case artifact $file missing from $dir") + got = sha256_file(path) + got == want || error("case artifact $file has SHA-256 $got but the manifest records $want") + end + end + + network_obj = JSON.parsefile(joinpath(dir, "network.json")) + network_obj["schema"] == BATTERY_NETWORK_SCHEMA || + error("unexpected network schema $(network_obj["schema"])") + network = plain(network_obj["data"])::Dict{String,Any} + + batteries_obj = JSON.parsefile(joinpath(dir, "batteries.json")) + batteries_obj["schema"] == BATTERY_BATTERY_SCHEMA || + error("unexpected batteries schema $(batteries_obj["schema"])") + batteries = BatterySpec[ + BatterySpec(Int(b["index"]), Int(b["bus"]), + Float64(b["energy_min"]), Float64(b["energy_max"]), + Float64(b["energy_initial"]), + Float64(b["charge_max"]), Float64(b["discharge_max"]), + Float64(b["charge_efficiency"]), Float64(b["discharge_efficiency"]), + Float64(b["self_discharge"]), Float64(b["throughput_cost"])) + for b in batteries_obj["batteries"]] + sort!(batteries; by = b -> b.index) + recourse = RecourseCosts(Float64(batteries_obj["recourse"]["deficit_cost"]), + Float64(batteries_obj["recourse"]["surplus_cost"])) + + demand_obj = JSON.parsefile(joinpath(dir, "demand.json")) + demand_obj["schema"] == BATTERY_DEMAND_SCHEMA || + error("unexpected demand schema $(demand_obj["schema"])") + load_ids = Int.(demand_obj["load_ids"]) + T = Int(demand_obj["horizon"]) + n = length(load_ids) + profile = Matrix{Float64}(undef, n, T) + for t in 1:T + col = Float64.(demand_obj["profile"][t]) + length(col) == n || + error("demand.json profile row $t has $(length(col)) entries, expected $n") + profile[:, t] .= col + end + atoms = Vector{Matrix{Float64}}(undef, T) + probs = Vector{Vector{Float64}}(undef, T) + for t in 1:T + raw = demand_obj["atoms"][t] + K = length(raw) + A = Matrix{Float64}(undef, n, K) + for k in 1:K + col = Float64.(raw[k]) + length(col) == n || + error("demand.json stage $t atom $k has $(length(col)) entries, expected $n") + A[:, k] .= col + end + atoms[t] = A + probs[t] = Float64.(demand_obj["probabilities"][t]) + end + demand = DemandSupport(Float64(demand_obj["stage_hours"]), T, load_ids, + profile, atoms, probs, + Int(demand_obj["protocol_seed"]), + plain(get(demand_obj, "source", Dict{String,Any}()))) + + # ── Fail-closed contract checks ───────────────────────────────────────── + # Each of these has a documented failure mode behind it; none is cosmetic. + validate_support(demand) + demand.stage_hours == Float64(manifest["stage_hours"]) || + error("demand.json stage_hours $(demand.stage_hours) disagrees with manifest $(manifest["stage_hours"])") + network_load_ids = sort!([Int(l["index"]) for (_, l) in network["load"]]) + demand.load_ids == network_load_ids || + error("demand support covers loads $(demand.load_ids) but the network has $(network_load_ids)") + bus_ids = Set(Int(b["index"]) for (_, b) in network["bus"]) + for b in batteries + b.bus in bus_ids || error("battery $(b.index) sits at bus $(b.bus), which is not in the network") + 0 < b.charge_efficiency <= 1 || error("battery $(b.index): charge_efficiency out of (0,1]") + 0 < b.discharge_efficiency <= 1 || error("battery $(b.index): discharge_efficiency out of (0,1]") + 0 < b.self_discharge <= 1 || error("battery $(b.index): self_discharge out of (0,1]") + b.energy_min <= b.energy_initial <= b.energy_max || + error("battery $(b.index): initial energy $(b.energy_initial) outside [$(b.energy_min), $(b.energy_max)]") + b.charge_max >= 0 && b.discharge_max >= 0 || + error("battery $(b.index): negative power rating") + b.throughput_cost >= 0 || error("battery $(b.index): negative throughput cost") + end + allunique(b.index for b in batteries) || error("battery indices are not unique") + recourse.deficit > 0 && recourse.surplus > 0 || + error("recourse prices must be strictly positive; got $(recourse)") + recourse.deficit == Float64(manifest["recourse"]["deficit_cost"]) && + recourse.surplus == Float64(manifest["recourse"]["surplus_cost"]) || + error("batteries.json recourse prices disagree with the manifest") + if verify + want_support = manifest["support"]["sha256"] + got_support = support_digest(demand) + got_support == want_support || + error("regenerated support digest $got_support does not match the manifest's $want_support") + want = manifest["protocol"]["sha256"] + got = protocol_digest(demand, Int(manifest["protocol"]["num_stages"]), + Int(manifest["protocol"]["num_scenarios"])) + got == want || + error("regenerated protocol digest $got does not match the manifest's $want") + scr = get(manifest, "screening", nothing) + if scr !== nothing + wants = scr["sha256"] + gots = protocol_digest(demand, Int(scr["num_stages"]), + Int(scr["num_scenarios"]); seed = Int(scr["seed"])) + gots == wants || + error("regenerated screening digest $gots does not match the manifest's $wants") + end + end + + return BatteryCase(String(dir), String(manifest["case"]), network, batteries, + recourse, demand, manifest) +end + +""" + _sampler_kind(d) -> String + +A one-line name for a recorded authoring sampler. + +# Notes +The full description is a nested dictionary that can run to thousands of +characters on a stage-dependent regional sampler. It stays in the artifact, where +it belongs; a case summary that scrolled it off the screen would be worse than +useless. +""" +function _sampler_kind(d) + d isa AbstractDict || return "(unrecorded)" + kind = String(get(d, "sampler", "?")) + kind == "product" && return "product(" * + join([_sampler_kind(c) for c in get(d, "components", [])], " × ") * ")" + if kind == "stage" + inner = sort!(unique([_sampler_kind(v) for (_, v) in get(d, "stages", Dict())])) + return "stage[" * join(inner, "|") * "]" + end + kind == "group" && return "group(" * string(length(get(d, "groups", []))) * " regions)" + return kind +end + +""" + describe(case::BatteryCase) -> String + +One-screen human summary of a frozen case: counts, stage duration, battery +ratings and the demand support. +""" +function describe(case::BatteryCase) + s = case.demand + io = IOBuffer() + println(io, "battery case: ", case.name, " (", case.dir, ")") + @printf(io, " buses %d gens %d branches %d loads %d baseMVA %.1f\n", + length(case.network["bus"]), length(case.network["gen"]), + length(case.network["branch"]), length(case.network["load"]), + Float64(case.network["baseMVA"])) + @printf(io, " stage duration %.4f h horizon %d loads in support %d\n", + s.stage_hours, s.horizon, num_loads(s)) + ks = [num_atoms(s, t) for t in 1:s.horizon] + @printf(io, " atoms per stage: min %d max %d support sha %s\n", + minimum(ks), maximum(ks), support_digest(s)[1:16]) + @printf(io, " profile range over stages: [%.4f, %.4f]\n", + minimum(s.profile), maximum(s.profile)) + @printf(io, " authoring sampler: %s (freeze %s, seed %s)\n", + _sampler_kind(get(s.source, "sampler", nothing)), + get(s.source, "method", "?"), string(get(s.source, "seed", "?"))) + @printf(io, " recourse prices: deficit %.1f surplus %.1f (per pu per stage)\n", + case.recourse.deficit, case.recourse.surplus) + for b in case.batteries + @printf(io, " battery %d @ bus %-4d e∈[%.4f, %.4f] e0=%.4f pch≤%.4f pdis≤%.4f η=(%.3f,%.3f) α=%.4f c_deg=%.4f\n", + b.index, b.bus, b.energy_min, b.energy_max, b.energy_initial, + b.charge_max, b.discharge_max, + b.charge_efficiency, b.discharge_efficiency, + b.self_discharge, b.throughput_cost) + end + return String(take!(io)) +end diff --git a/examples/BatteryStorageOPF/battery_exa.jl b/examples/BatteryStorageOPF/battery_exa.jl new file mode 100644 index 0000000..915e55c --- /dev/null +++ b/examples/BatteryStorageOPF/battery_exa.jl @@ -0,0 +1,1056 @@ +# battery_exa.jl +# +# The GPU engine's model: a multistage, strict-target battery-storage AC-OPF +# deterministic equivalent written directly in ExaModels. +# +# This is the ONLY manually written network formulation in the project, and it +# exists because there is no equally validated PowerModels-to-ExaModels bridge. +# Its correctness is not asserted — it is MEASURED, by differencing every +# physical variable against the actual `PowerModels.ACPPowerModel` that the JuMP +# engine builds from the same frozen case. +# +# What is here: +# * a parser from the frozen `network.json` into flat, positionally indexed +# arrays, with explicit identifier→position maps so nonconsecutive PGLib +# component identifiers are handled correctly; +# * the full AC polar formulation — reference angle, Ohm's law at both ends +# with transformer taps and phase shifts, angle-difference limits, +# apparent-power limits at BOTH branch ends, shunts, generator boxes and +# polynomial costs, and a HARD reactive balance; +# * the battery layer — charge/discharge controls, the state transition with +# the outgoing energy held as a PARAMETER (strict targets), unity-power- +# factor injection, throughput cost; +# * the two-sided uncapped nodal active recourse, priced exactly as the JuMP +# engine prices it. +# +# What is deliberately NOT here: any SOC-WR model. SDDP does not run through +# this engine, and TS-DDR trains and evaluates on true ACP throughout. +# +# There is exactly ONE formulation: strict. There is no soft-target, no +# penalized-target and no target-deficit variant, here or anywhere else in the +# supported workflow. +# +# STRICT-MODE INVARIANT. The energy trajectory is an ExaModels PARAMETER of +# length `(T+1)·nBat` laid out as `[e_0; \hat e_1; …; \hat e_T]`. Because it is +# a parameter, an explicit initial-condition row `e_0 = x_0` would be a +# parameter-only constraint — an all-zero Jacobian row — so it is omitted and +# the initial condition is maintained by DATA: every writer of the energy +# parameter must keep its first `nBat` entries equal to `x_0`. +# `set_energy_path!` is the only writer and it guarantees this. + +using ExaModels +using MadNLP +using JSON +using LinearAlgebra +using Logging +using Printf +# The three verbs below are DecisionRulesExa generics; this file adds the +# battery problem's methods to them rather than shadowing the names, so a script +# that has the package in scope keeps one meaning for each verb. +import DecisionRulesExa: solve!, target_multipliers, solve_succeeded + +# ───────────────────────────────────────────────────────────────────────────── +# Flat index helpers +# +# Every array is stage-major: entry (t, i) lives at (t-1)*n + i. The energy +# parameter is the one exception — it is indexed from stage 0 — and has its own +# helper so the off-by-one can never be re-derived by hand at a call site. +# ───────────────────────────────────────────────────────────────────────────── + +@inline _bi(nBus, t, i) = (t - 1) * nBus + i # bus-indexed, stages 1..T +@inline _gi(nGen, t, g) = (t - 1) * nGen + g # generator-indexed +@inline _bri(nBr, t, l) = (t - 1) * nBr + l # branch-indexed +@inline _bti(nBat, t, b) = (t - 1) * nBat + b # battery-indexed, stages 1..T +@inline _ei(nBat, t, b) = t * nBat + b # energy parameter, stages 0..T + +# ───────────────────────────────────────────────────────────────────────────── +# Network data +# ───────────────────────────────────────────────────────────────────────────── + +""" + ExaBusData + +One bus, in positional form. + +# Fields +- `id::Int`: the network identifier (arbitrary, possibly nonconsecutive). +- `bus_type::Int`: 1 PQ, 2 PV, 3 reference, 4 isolated. +- `gs::Float64`, `bs::Float64`: TOTAL shunt conductance/susceptance at the bus, + aggregated over the case's shunt table (pu). +- `vmin::Float64`, `vmax::Float64`: voltage-magnitude bounds (pu). +""" +struct ExaBusData + id::Int + bus_type::Int + gs::Float64 + bs::Float64 + vmin::Float64 + vmax::Float64 +end + +""" + ExaGenData + +One generator, in positional form. + +# Fields +- `id::Int`: network identifier. +- `bus_pos::Int`: POSITION of its bus in the bus array. +- `pmin`, `pmax`, `qmin`, `qmax`: capability box (pu), as the case declares it, + BEFORE any per-stage availability is applied. +- `c2`, `c1`, `c0`: polynomial cost coefficients such that the generator's cost + is ``c_2 p^2 + c_1 p + c_0`` with `p` in pu. +- `availability::Vector{Float64}`: the case's per-stage availability schedule for + this unit, read from [`STAGE_AVAILABILITY_KEY`](@ref). EMPTY means the unit + carries no schedule and is available in every stage — which is what every case + built before the convention existed says, and why the field is additive. +""" +struct ExaGenData + id::Int + bus_pos::Int + pmin::Float64 + pmax::Float64 + qmin::Float64 + qmax::Float64 + c2::Float64 + c1::Float64 + c0::Float64 + availability::Vector{Float64} +end + +""" + ExaBranchData + +One branch, in positional form, with the raw MATPOWER/PowerModels π-model +parameters the AC polar equations need. + +# Fields +- `id::Int`: network identifier. +- `f_pos::Int`, `t_pos::Int`: POSITIONS of the from/to buses. +- `br_r`, `br_x`: series resistance and reactance (pu). +- `g_fr`, `b_fr`, `g_to`, `b_to`: line-charging shunts at each end (pu). +- `tap`, `shift`: transformer turns ratio and phase shift (rad). +- `rate_a`: apparent-power limit (pu). +- `angmin`, `angmax`: angle-difference limits (rad). +""" +struct ExaBranchData + id::Int + f_pos::Int + t_pos::Int + br_r::Float64 + br_x::Float64 + g_fr::Float64 + b_fr::Float64 + g_to::Float64 + b_to::Float64 + tap::Float64 + shift::Float64 + rate_a::Float64 + angmin::Float64 + angmax::Float64 +end + +""" + ExaNetwork + +The frozen network in the flat, positional form the ExaModels builder needs. + +# Fields +- `buses`, `gens`, `branches`: sorted by network identifier. +- `bus_pos::Dict{Int,Int}`: identifier → position. Nothing anywhere assumes an + identifier equals a position. +- `ref_bus_positions::Vector{Int}`: positions of the reference buses. +- `baseMVA::Float64`. +- `nominal_pd`, `nominal_qd::Vector{Float64}`: nominal per-bus demand (pu), + aggregated over the case's load table and indexed by bus POSITION. + +# Notes +Sorting by identifier is what makes the layout reproducible: dictionary +iteration order is not, and a variable vector whose meaning depends on hash +order cannot be compared with another engine's. + +Inactive components are dropped exactly as PowerModels drops them — buses with +`bus_type == 4`, generators with `gen_status == 0`, branches with +`br_status == 0`, loads and shunts with `status == 0` — so both engines see the +same system. +""" +struct ExaNetwork + buses::Vector{ExaBusData} + gens::Vector{ExaGenData} + branches::Vector{ExaBranchData} + bus_pos::Dict{Int,Int} + ref_bus_positions::Vector{Int} + baseMVA::Float64 + nominal_pd::Vector{Float64} + nominal_qd::Vector{Float64} +end + +nbus(net::ExaNetwork) = length(net.buses) +ngen(net::ExaNetwork) = length(net.gens) +nbranch(net::ExaNetwork) = length(net.branches) + +# ───────────────────────────────────────────────────────────────────────────── +# Per-stage generator availability +# +# The case may declare, for any generator, a per-stage multiplier on its whole +# capability box (see `STAGE_AVAILABILITY_KEY` in `battery_case.jl`). The JuMP +# engine applies it to the parsed network just before PowerModels instantiates a +# stage; this engine builds every stage of the horizon at once, so it applies it +# to the VARIABLE BOUNDS of each stage's generator block instead. The two +# statements are the same statement — `pmin`, `pmax`, `qmin` and `qmax` scaled by +# the same multiplier — made in the only place each engine has to make it. +# +# The schedule is DATA. It reaches the model through `lvar`/`uvar` and through +# nothing else: no objective term, no constraint coefficient, no parameter. That +# is what keeps it off every automatic-differentiation path in the trainer, whose +# gradient flows through the energy parameter and the multipliers only. +# ───────────────────────────────────────────────────────────────────────────── + +""" + gen_availability(gen) -> Vector{Float64} + +The per-stage availability schedule declared by one raw generator row, or an +empty vector when it declares none. + +# Notes +Rejected, rather than repaired: a schedule that is not a non-empty vector, a +multiplier that is not finite, and a multiplier outside `[0, 1]`. Availability is +a FRACTION of a declared capability — a value above one would silently give a +unit more capacity than the case says it has, and the case is the only place +capacity may be stated. +""" +function gen_availability(gen::AbstractDict) + haskey(gen, STAGE_AVAILABILITY_KEY) || return Float64[] + sched = gen[STAGE_AVAILABILITY_KEY] + (sched isa AbstractVector && !isempty(sched)) || + error("generator $(get(gen, "index", "?")): \"$STAGE_AVAILABILITY_KEY\" must be a non-empty vector of multipliers") + av = Float64.(collect(sched)) + all(a -> isfinite(a) && 0 <= a <= 1, av) || + error("generator $(get(gen, "index", "?")): availability multipliers must be finite and in [0, 1], got $av") + return av +end + +""" + availability_at(g::ExaGenData, t::Integer) -> Float64 + +Generator `g`'s availability multiplier at stage `t`. + +# Notes +Fails closed on a schedule that does not cover `t`, exactly as the JuMP engine +does: a case declaring a two-stage schedule that is then built over three stages +has been mixed up with a different case, and reusing the last entry would hide +that. A unit carrying no schedule is available in every stage, and the multiplier +returned for it is exactly `1.0` — which the bound builder recognises and skips, +so a case without schedules produces bit-identical bounds to one built before +this convention existed. +""" +@inline function availability_at(g::ExaGenData, t::Integer) + isempty(g.availability) && return 1.0 + t <= length(g.availability) || + error("generator $(g.id): \"$STAGE_AVAILABILITY_KEY\" covers $(length(g.availability)) stages but stage $t was requested") + return g.availability[t] +end + +# Scale one bound, leaving it untouched at full availability. `a == 1` is exact +# for the multiplier written by a case that means "available", and the branch +# also keeps `±Inf` bounds out of a `Inf * 0 == NaN`. +@inline _avail_scale(v::Real, a::Real) = a == 1 ? Float64(v) : Float64(v) * Float64(a) + +""" + exa_network(case::BatteryCase) -> ExaNetwork + +Build the flat positional network from a frozen case. + +# Notes +No PowerModels call appears here or anywhere else in this engine: the frozen +`network.json` is the interface between the two engines, and it holds the case +exactly as PGLib/PowerModels parsed it. + +Generator cost coefficients are read from PowerModels' highest-order-first +polynomial with `ncost` terms and re-expressed as ``(c_2, c_1, c_0)``. A model +with more than three terms is rejected rather than truncated. +""" +function exa_network(case::BatteryCase) + data = case.network + + bus_rows = sort!([b for (_, b) in data["bus"] if Int(b["bus_type"]) != 4]; + by = b -> Int(b["index"])) + bus_pos = Dict{Int,Int}(Int(b["index"]) => i for (i, b) in enumerate(bus_rows)) + + # Shunts live in their own table; a bus may carry several. + gs = zeros(Float64, length(bus_rows)) + bs = zeros(Float64, length(bus_rows)) + for (_, sh) in get(data, "shunt", Dict{String,Any}()) + Int(get(sh, "status", 1)) == 0 && continue + p = get(bus_pos, Int(sh["shunt_bus"]), 0) + p == 0 && continue + gs[p] += Float64(get(sh, "gs", 0.0)) + bs[p] += Float64(get(sh, "bs", 0.0)) + end + + buses = [ExaBusData(Int(b["index"]), Int(b["bus_type"]), gs[i], bs[i], + Float64(get(b, "vmin", 0.9)), Float64(get(b, "vmax", 1.1))) + for (i, b) in enumerate(bus_rows)] + ref_positions = [i for (i, b) in enumerate(buses) if b.bus_type == 3] + isempty(ref_positions) && error("exa_network: the case declares no reference bus") + + gen_rows = sort!([g for (_, g) in data["gen"] + if Int(get(g, "gen_status", 1)) != 0 && + haskey(bus_pos, Int(g["gen_bus"]))]; + by = g -> Int(g["index"])) + gens = ExaGenData[] + for g in gen_rows + Int(get(g, "model", 2)) == 2 || + error("exa_network: generator $(g["index"]) has a non-polynomial cost model") + cost = Float64.(g["cost"]) + n = Int(g["ncost"]) + n <= 3 || error("exa_network: generator $(g["index"]) has a degree-$(n-1) cost polynomial") + tail = cost[(end - n + 1):end] + c2 = n >= 3 ? tail[end - 2] : 0.0 + c1 = n >= 2 ? tail[end - 1] : 0.0 + c0 = n >= 1 ? tail[end] : 0.0 + av = gen_availability(g) + pmin, pmax = Float64(get(g, "pmin", 0.0)), Float64(g["pmax"]) + qmin, qmax = Float64(get(g, "qmin", -Inf)), Float64(get(g, "qmax", Inf)) + # Bound consistency is checked for SCHEDULED units only. Scaling by a + # nonnegative multiplier preserves the order of an interval, so a + # schedule can never create an inconsistency the case did not already + # carry; and checking every unit would let this engine REJECT a case that + # built before the convention existed, which the additivity requirement + # forbids. A scheduled unit is new data, so it is checked where it is read. + if !isempty(av) + pmin <= pmax || + error("generator $(g["index"]): scheduled unit has pmin $pmin above pmax $pmax") + qmin <= qmax || + error("generator $(g["index"]): scheduled unit has qmin $qmin above qmax $qmax") + end + push!(gens, ExaGenData(Int(g["index"]), bus_pos[Int(g["gen_bus"])], + pmin, pmax, qmin, qmax, c2, c1, c0, av)) + end + + br_rows = sort!([b for (_, b) in data["branch"] + if Int(get(b, "br_status", 1)) != 0 && + haskey(bus_pos, Int(b["f_bus"])) && haskey(bus_pos, Int(b["t_bus"]))]; + by = b -> Int(b["index"])) + branches = ExaBranchData[] + for b in br_rows + tap = Float64(get(b, "tap", 1.0)) + tap = tap ≈ 0 ? 1.0 : tap # PowerModels treats a zero tap as 1 + push!(branches, ExaBranchData( + Int(b["index"]), bus_pos[Int(b["f_bus"])], bus_pos[Int(b["t_bus"])], + Float64(get(b, "br_r", 0.0)), Float64(b["br_x"]), + Float64(get(b, "g_fr", 0.0)), Float64(get(b, "b_fr", 0.0)), + Float64(get(b, "g_to", 0.0)), Float64(get(b, "b_to", 0.0)), + tap, Float64(get(b, "shift", 0.0)), + Float64(get(b, "rate_a", Inf)), + Float64(get(b, "angmin", -pi)), Float64(get(b, "angmax", pi)))) + end + + pd = zeros(Float64, length(buses)) + qd = zeros(Float64, length(buses)) + for (_, l) in data["load"] + Int(get(l, "status", 1)) == 0 && continue + p = get(bus_pos, Int(l["load_bus"]), 0) + p == 0 && continue + pd[p] += Float64(l["pd"]) + qd[p] += Float64(l["qd"]) + end + + return ExaNetwork(buses, gens, branches, bus_pos, ref_positions, + Float64(data["baseMVA"]), pd, qd) +end + +""" + branch_coefficients(br, T) -> NamedTuple + +Precompute the eight AC-polar branch coefficients in element type `T`. + +# Notes +With ``t_r = \\tau\\cos\\theta_s``, ``t_i = \\tau\\sin\\theta_s``, +``t_m = t_r^2 + t_i^2``, ``g + jb = 1/(r + jx)``: + +```math +\\begin{aligned} +c_1 &= (-g t_r - b t_i)/t_m, & c_2 &= (-b t_r + g t_i)/t_m,\\\\ +c_3 &= (-g t_r + b t_i)/t_m, & c_4 &= (-b t_r - g t_i)/t_m,\\\\ +c_5 &= (g + g^{fr})/t_m, & c_6 &= (b + b^{fr})/t_m,\\\\ +c_7 &= g + g^{to}, & c_8 &= b + b^{to}, +\\end{aligned} +``` + +so that, writing ``\\theta = \\theta_f - \\theta_t``, + +```math +\\begin{aligned} +p^{fr} &= c_5 v_f^2 + c_3 v_f v_t \\cos\\theta + c_4 v_f v_t \\sin\\theta,\\\\ +q^{fr} &= -c_6 v_f^2 - c_4 v_f v_t \\cos\\theta + c_3 v_f v_t \\sin\\theta,\\\\ +p^{to} &= c_7 v_t^2 + c_1 v_t v_f \\cos(-\\theta) + c_2 v_t v_f \\sin(-\\theta),\\\\ +q^{to} &= -c_8 v_t^2 - c_2 v_t v_f \\cos(-\\theta) + c_1 v_t v_f \\sin(-\\theta). +\\end{aligned} +``` + +This is PowerModels' `constraint_ohms_yt_from`/`_to` for the polar AC form, +transformer taps and phase shifts included. A zero `t_m` (only reachable from a +degenerate tap) is replaced by 1 so the model builds; the case verifier rejects +such data upstream. +""" +function branch_coefficients(br::ExaBranchData, ::Type{T}) where {T} + r2x2 = br.br_r^2 + br.br_x^2 + g = r2x2 > 0 ? T(br.br_r / r2x2) : zero(T) + b = r2x2 > 0 ? T(-br.br_x / r2x2) : zero(T) + tr = T(br.tap) * cos(T(br.shift)) + ti = T(br.tap) * sin(T(br.shift)) + ttm = tr^2 + ti^2 + ttm = ttm > 0 ? ttm : one(T) + return (c1 = (-g * tr - b * ti) / ttm, + c2 = (-b * tr + g * ti) / ttm, + c3 = (-g * tr + b * ti) / ttm, + c4 = (-b * tr - g * ti) / ttm, + c5 = (g + T(br.g_fr)) / ttm, + c6 = (b + T(br.b_fr)) / ttm, + c7 = g + T(br.g_to), + c8 = b + T(br.b_to)) +end + +# ───────────────────────────────────────────────────────────────────────────── +# The deterministic equivalent +# ───────────────────────────────────────────────────────────────────────────── + +""" + BatteryExaProblem + +A `T`-stage strict-target battery-storage AC-OPF deterministic equivalent. + +# Fields +- `core`, `model`: the `ExaCore` and the built `ExaModel`. +- `net::ExaNetwork`, `case::BatteryCase`: the data the model was built from. +- `batteries::Vector{BatterySpec}`: sorted by identifier; battery `b` occupies + position `b` in every flat battery array. +- `p_pd`, `p_qd`: per-bus per-stage demand parameters (length `T·nBus`). +- `p_energy`: the energy trajectory parameter, length `(T+1)·nBat`, laid out + `[e_0; \\hat e_1; …; \\hat e_T]`. See the STRICT-MODE INVARIANT at the top of + this file. +- `energy_values::Vector{Float64}`: the last trajectory written, kept so the + solution extractor can report the state without reading a parameter back off + a device. +- `transition_range::UnitRange{Int}`: rows of `result.multipliers` holding the + battery state-transition duals. +- `Δt::Float64`: stage duration in hours. +- `stages::Vector{Int}`: which CASE stage each of the model's `T` positions is. + `1:T` for a model built from the start of the horizon; anything else for a + window. It matters only for data that is indexed by case stage rather than by + position — today that is the per-stage generator availability, which is baked + into the variable bounds at build time and therefore cannot be re-pointed at a + different window afterwards. +- `horizon::Int`, `nBus`, `nGen`, `nBranch`, `nBat::Int`: sizes. +""" +struct BatteryExaProblem{C,M,P1,P2,P3} + core::C + model::M + net::ExaNetwork + case::BatteryCase + batteries::Vector{BatterySpec} + p_pd::P1 + p_qd::P2 + p_energy::P3 + energy_values::Vector{Float64} + transition_range::UnitRange{Int} + Δt::Float64 + stages::Vector{Int} + horizon::Int + nBus::Int + nGen::Int + nBranch::Int + nBat::Int +end + +"True when any generator of `prob` carries a per-stage availability schedule." +has_stage_schedule(net::ExaNetwork) = any(g -> !isempty(g.availability), net.gens) +has_stage_schedule(prob::BatteryExaProblem) = has_stage_schedule(prob.net) + +""" + assert_stage_window(prob, stages) + +Check that `stages` is the window `prob` was BUILT for, and fail if it is not. + +# Notes +Demand is written into parameters, so one built model can serve any window of the +horizon by re-imposing the demand — which is how the trainer solves a rolling +window. Availability is not data of that kind: it lives in the variable bounds +and is fixed when the model is built. A case with no schedule is therefore free +to be solved at any offset, exactly as before this convention existed, and a case +WITH one may only be solved on its own window. The alternative — silently solving +stage 5 with stage 1's availability — is the failure this study cannot afford. +""" +function assert_stage_window(prob::BatteryExaProblem, stages::AbstractVector{<:Integer}) + has_stage_schedule(prob) || return nothing + collect(Int, stages) == prob.stages || + error("this problem was built for case stages $(prob.stages) and its generator " * + "availability is baked into its bounds; it cannot be solved for stages " * + "$(collect(Int, stages)). Build a problem for that window instead.") + return nothing +end + +""" + build_battery_exa(case, T; backend=nothing, float_type=Float64, stages=1:T) + -> BatteryExaProblem + +Build the `T`-stage strict deterministic equivalent. + +# Arguments +- `case::BatteryCase`: the frozen case. +- `T::Int`: horizon. + +# Keywords +- `backend`: `nothing` for CPU, or a KernelAbstractions backend (e.g. + `CUDABackend()`) for GPU. +- `float_type`: working precision. `Float64` throughout the study; the AC + equations are ill-conditioned enough that reduced precision changes answers. +- `stages`: which CASE stage each of the `T` model positions is, `1:T` by + default. Pass a window (`stages = 2:3`, or `[2]` for a single continuation + problem) to build the model a case's LATER stages describe. It changes exactly + one thing — which entry of each generator's availability schedule is applied — + and a case that declares no schedule builds identically for every `stages`. + +# Returns +- The [`BatteryExaProblem`](@ref). + +# Notes +Constraint ORDER is part of the contract, because the target multipliers are a +slice of `result.multipliers`. The order is: reference angle, the four branch +flow definitions, angle-difference limits, apparent-power limits at each end, +active balance, reactive balance, and LAST the battery state transitions — +whose rows `transition_range` records. + +The stage problems of a strict trajectory are COUPLED only through the energy +parameter, which is data; the deterministic equivalent is nonetheless built as +one model so a single solve produces the whole trajectory and all its +multipliers. + +A generator the case schedules out of some stage keeps its variables, its cost +row and its position in every flat array — only its bounds close to zero in that +stage. The model's SHAPE is therefore the same whatever the schedule says, which +is what lets one built problem be re-solved across atoms and horizons, and it +matches the JuMP engine, which scales the same four limits rather than flipping +`gen_status` (PowerModels would drop an out-of-service unit from `ref` and change +the variable set). The constant term of a scheduled-out unit's cost polynomial is +still added, in both engines, because a polynomial cost evaluated at a pinned +zero is exactly `c_0`. +""" +function build_battery_exa(case::BatteryCase, T::Int; + backend = nothing, + float_type::Type{<:AbstractFloat} = Float64, + stages::AbstractVector{<:Integer} = 1:T) + T >= 1 || throw(ArgumentError("horizon must be at least 1")) + stage_of = collect(Int, stages) + length(stage_of) == T || + throw(ArgumentError("stages must name one case stage per model position, got $(length(stage_of)) for T=$T")) + all(>=(1), stage_of) || throw(ArgumentError("stages must be 1-based, got $stage_of")) + net = exa_network(case) + batteries = sort(collect(case.batteries); by = b -> b.index) + nB, nG, nBR, nBat = nbus(net), ngen(net), nbranch(net), length(batteries) + Δt = float_type(stage_hours(case)) + bat_pos = [net.bus_pos[b.bus] for b in batteries] + for (b, p) in zip(batteries, bat_pos) + p > 0 || error("battery $(b.index) sits at bus $(b.bus), which is not an active bus") + end + + # `concrete = Val(false)` keeps the MUTABLE core, which is what + # `ExaModels.constraint!` needs in order to add terms to an existing + # constraint row — the nodal balances below are assembled that way. It is + # passed explicitly because the default is scheduled to flip. ExaModels + # emits a deprecation warning for the mutable core; it is silenced HERE + # ONLY, around this single call, because a model build happens once per run + # while the warning would otherwise print on every one of them. + core = Logging.with_logger(Logging.NullLogger()) do + ExaModels.ExaCore(float_type; backend = backend, concrete = Val(false)) + end + + # ── Variables, in the order the extractor unpacks them ─────────────────── + va = ExaModels.variable(core, T * nB) + vm = ExaModels.variable(core, T * nB; + lvar = float_type.(repeat([b.vmin for b in net.buses], T)), + uvar = float_type.(repeat([b.vmax for b in net.buses], T)), + start = ones(float_type, T * nB)) + # Generator boxes are per STAGE, because the case may take a unit out of + # service in some stages and not others (see `availability_at`). The + # comprehension runs `t` outermost so the layout is stage-major, exactly as + # `_gi` indexes it and exactly as the `repeat` it replaces laid it out; at + # full availability every entry is the same Float64 as before. + # + # The infinite reactive bounds are substituted BEFORE scaling: a case that + # leaves `qmin` unstated means "unlimited", and `-Inf * 0` is `NaN`, not the + # zero an unavailable unit must have. + pg = ExaModels.variable(core, T * nG; + lvar = float_type[_avail_scale(g.pmin, availability_at(g, s)) for s in stage_of for g in net.gens], + uvar = float_type[_avail_scale(g.pmax, availability_at(g, s)) for s in stage_of for g in net.gens]) + qg = ExaModels.variable(core, T * nG; + lvar = float_type[_avail_scale(isfinite(g.qmin) ? g.qmin : -1e4, availability_at(g, s)) + for s in stage_of for g in net.gens], + uvar = float_type[_avail_scale(isfinite(g.qmax) ? g.qmax : 1e4, availability_at(g, s)) + for s in stage_of for g in net.gens]) + # Branch flow boxes are ±rate_a, exactly as PowerModels' bounded branch + # power variables are; the apparent-power disks below are what actually + # binds, and a box alone would be a strictly weaker (square) relaxation. + flow_lb = float_type.(repeat([-b.rate_a for b in net.branches], T)) + flow_ub = float_type.(repeat([b.rate_a for b in net.branches], T)) + p_fr = ExaModels.variable(core, T * nBR; lvar = flow_lb, uvar = flow_ub) + q_fr = ExaModels.variable(core, T * nBR; lvar = flow_lb, uvar = flow_ub) + p_to = ExaModels.variable(core, T * nBR; lvar = flow_lb, uvar = flow_ub) + q_to = ExaModels.variable(core, T * nBR; lvar = flow_lb, uvar = flow_ub) + + # Two-sided physical active recourse: nonnegative, and with NO upper bound + # of any kind. Capping `deficit` by the realized demand would destroy + # relatively complete recourse for strict charging targets. + deficit = ExaModels.variable(core, T * nB; lvar = float_type(0)) + surplus = ExaModels.variable(core, T * nB; lvar = float_type(0)) + + p_ch = ExaModels.variable(core, T * nBat; lvar = float_type(0), + uvar = float_type.(repeat([b.charge_max for b in batteries], T))) + p_dis = ExaModels.variable(core, T * nBat; lvar = float_type(0), + uvar = float_type.(repeat([b.discharge_max for b in batteries], T))) + + # ── Parameters ─────────────────────────────────────────────────────────── + p_pd = ExaModels.parameter(core, float_type.(repeat(net.nominal_pd, T))) + p_qd = ExaModels.parameter(core, float_type.(repeat(net.nominal_qd, T))) + p_energy = ExaModels.parameter(core, zeros(float_type, (T + 1) * nBat)) + + coeff = [branch_coefficients(br, float_type) for br in net.branches] + + # ── Objective ──────────────────────────────────────────────────────────── + gen_items = [(t = t, g = i, c2 = float_type(g.c2), c1 = float_type(g.c1), c0 = float_type(g.c0)) + for t in 1:T for (i, g) in enumerate(net.gens)] + ExaModels.objective(core, + item.c2 * pg[_gi(nG, item.t, item.g)]^2 + + item.c1 * pg[_gi(nG, item.t, item.g)] + + item.c0 + for item in gen_items) + + rec_items = [(idx = _bi(nB, t, i), + cd = float_type(case.recourse.deficit), + cs = float_type(case.recourse.surplus)) + for t in 1:T for i in 1:nB] + ExaModels.objective(core, + item.cd * deficit[item.idx] + item.cs * surplus[item.idx] + for item in rec_items) + + if nBat > 0 + thr_items = [(idx = _bti(nBat, t, k), c = float_type(b.throughput_cost) * Δt) + for t in 1:T for (k, b) in enumerate(batteries)] + ExaModels.objective(core, + item.c * (p_ch[item.idx] + p_dis[item.idx]) for item in thr_items) + end + + n_con = 0 + + # ── 1. Reference angle ─────────────────────────────────────────────────── + ExaModels.constraint(core, + va[_bi(nB, item.t, item.r)] + for item in [(t = t, r = r) for t in 1:T for r in net.ref_bus_positions]) + n_con += T * length(net.ref_bus_positions) + + # ── 2-5. Branch flows at both ends ─────────────────────────────────────── + fr_items = [(t = t, l = l, f = br.f_pos, tb = br.t_pos, + c3 = coeff[l].c3, c4 = coeff[l].c4, c5 = coeff[l].c5, c6 = coeff[l].c6) + for t in 1:T for (l, br) in enumerate(net.branches)] + to_items = [(t = t, l = l, f = br.f_pos, tb = br.t_pos, + c1 = coeff[l].c1, c2 = coeff[l].c2, c7 = coeff[l].c7, c8 = coeff[l].c8) + for t in 1:T for (l, br) in enumerate(net.branches)] + + ExaModels.constraint(core, + p_fr[_bri(nBR, item.t, item.l)] + - item.c5 * vm[_bi(nB, item.t, item.f)]^2 + - item.c3 * vm[_bi(nB, item.t, item.f)] * vm[_bi(nB, item.t, item.tb)] + * cos(va[_bi(nB, item.t, item.f)] - va[_bi(nB, item.t, item.tb)]) + - item.c4 * vm[_bi(nB, item.t, item.f)] * vm[_bi(nB, item.t, item.tb)] + * sin(va[_bi(nB, item.t, item.f)] - va[_bi(nB, item.t, item.tb)]) + for item in fr_items) + ExaModels.constraint(core, + q_fr[_bri(nBR, item.t, item.l)] + + item.c6 * vm[_bi(nB, item.t, item.f)]^2 + + item.c4 * vm[_bi(nB, item.t, item.f)] * vm[_bi(nB, item.t, item.tb)] + * cos(va[_bi(nB, item.t, item.f)] - va[_bi(nB, item.t, item.tb)]) + - item.c3 * vm[_bi(nB, item.t, item.f)] * vm[_bi(nB, item.t, item.tb)] + * sin(va[_bi(nB, item.t, item.f)] - va[_bi(nB, item.t, item.tb)]) + for item in fr_items) + ExaModels.constraint(core, + p_to[_bri(nBR, item.t, item.l)] + - item.c7 * vm[_bi(nB, item.t, item.tb)]^2 + - item.c1 * vm[_bi(nB, item.t, item.tb)] * vm[_bi(nB, item.t, item.f)] + * cos(va[_bi(nB, item.t, item.tb)] - va[_bi(nB, item.t, item.f)]) + - item.c2 * vm[_bi(nB, item.t, item.tb)] * vm[_bi(nB, item.t, item.f)] + * sin(va[_bi(nB, item.t, item.tb)] - va[_bi(nB, item.t, item.f)]) + for item in to_items) + ExaModels.constraint(core, + q_to[_bri(nBR, item.t, item.l)] + + item.c8 * vm[_bi(nB, item.t, item.tb)]^2 + + item.c2 * vm[_bi(nB, item.t, item.tb)] * vm[_bi(nB, item.t, item.f)] + * cos(va[_bi(nB, item.t, item.tb)] - va[_bi(nB, item.t, item.f)]) + - item.c1 * vm[_bi(nB, item.t, item.tb)] * vm[_bi(nB, item.t, item.f)] + * sin(va[_bi(nB, item.t, item.tb)] - va[_bi(nB, item.t, item.f)]) + for item in to_items) + n_con += 4 * T * nBR + + # ── 6. Angle-difference limits ─────────────────────────────────────────── + ExaModels.constraint(core, + va[_bi(nB, item.t, item.f)] - va[_bi(nB, item.t, item.tb)] + for item in fr_items; + lcon = float_type.(repeat([br.angmin for br in net.branches], T)), + ucon = float_type.(repeat([br.angmax for br in net.branches], T))) + n_con += T * nBR + + # ── 7. Apparent-power limits at BOTH ends ──────────────────────────────── + thermal_ub = float_type.(repeat([br.rate_a^2 for br in net.branches], T)) + ExaModels.constraint(core, + p_fr[_bri(nBR, item.t, item.l)]^2 + q_fr[_bri(nBR, item.t, item.l)]^2 + for item in fr_items; + lcon = fill(float_type(-Inf), T * nBR), ucon = thermal_ub) + ExaModels.constraint(core, + p_to[_bri(nBR, item.t, item.l)]^2 + q_to[_bri(nBR, item.t, item.l)]^2 + for item in to_items; + lcon = fill(float_type(-Inf), T * nBR), ucon = thermal_ub) + n_con += 2 * T * nBR + + # ── 8. Active balance ──────────────────────────────────────────────────── + # Written as pd + gs·vm² − Σpg + Σp_fr + Σp_to − p^bat − d + s = 0, + # i.e. the plan's balance moved to one side. The battery injects + # p^bat = p^dis − p^ch, and the recourse pair enters with opposite signs. + kcl_p = ExaModels.constraint(core, + p_pd[_bi(nB, item.t, item.i)] + item.gs * vm[_bi(nB, item.t, item.i)]^2 + for item in [(t = t, i = i, gs = float_type(net.buses[i].gs)) for t in 1:T for i in 1:nB]) + ExaModels.constraint!(core, kcl_p, + item.row => -pg[item.col] + for item in [(row = _bi(nB, t, g.bus_pos), col = _gi(nG, t, k)) + for t in 1:T for (k, g) in enumerate(net.gens)]) + ExaModels.constraint!(core, kcl_p, + item.row => p_fr[item.col] + for item in [(row = _bi(nB, t, br.f_pos), col = _bri(nBR, t, l)) + for t in 1:T for (l, br) in enumerate(net.branches)]) + ExaModels.constraint!(core, kcl_p, + item.row => p_to[item.col] + for item in [(row = _bi(nB, t, br.t_pos), col = _bri(nBR, t, l)) + for t in 1:T for (l, br) in enumerate(net.branches)]) + ExaModels.constraint!(core, kcl_p, + item.row => -deficit[item.col] + surplus[item.col] + for item in [(row = _bi(nB, t, i), col = _bi(nB, t, i)) for t in 1:T for i in 1:nB]) + if nBat > 0 + ExaModels.constraint!(core, kcl_p, + item.row => -p_dis[item.col] + p_ch[item.col] + for item in [(row = _bi(nB, t, bat_pos[k]), col = _bti(nBat, t, k)) + for t in 1:T for k in 1:nBat]) + end + n_con += T * nB + + # ── 9. Reactive balance — HARD, no slack of any kind ───────────────────── + kcl_q = ExaModels.constraint(core, + p_qd[_bi(nB, item.t, item.i)] - item.bs * vm[_bi(nB, item.t, item.i)]^2 + for item in [(t = t, i = i, bs = float_type(net.buses[i].bs)) for t in 1:T for i in 1:nB]) + ExaModels.constraint!(core, kcl_q, + item.row => -qg[item.col] + for item in [(row = _bi(nB, t, g.bus_pos), col = _gi(nG, t, k)) + for t in 1:T for (k, g) in enumerate(net.gens)]) + ExaModels.constraint!(core, kcl_q, + item.row => q_fr[item.col] + for item in [(row = _bi(nB, t, br.f_pos), col = _bri(nBR, t, l)) + for t in 1:T for (l, br) in enumerate(net.branches)]) + ExaModels.constraint!(core, kcl_q, + item.row => q_to[item.col] + for item in [(row = _bi(nB, t, br.t_pos), col = _bri(nBR, t, l)) + for t in 1:T for (l, br) in enumerate(net.branches)]) + n_con += T * nB + + # ── 10. Battery state transition — ADDED LAST ──────────────────────────── + # e_t − α e_{t-1} − η^{ch} Δt p^{ch}_t + (Δt/η^{dis}) p^{dis}_t = 0, + # with e a PARAMETER. The duals of these rows are what + # `target_multipliers` turns into ∂Q/∂x̂. + transition_start = n_con + 1 + if nBat > 0 + ExaModels.constraint(core, + p_energy[_ei(nBat, item.t, item.k)] + - item.α * p_energy[_ei(nBat, item.t - 1, item.k)] + - item.ηc * p_ch[_bti(nBat, item.t, item.k)] + + item.ηd * p_dis[_bti(nBat, item.t, item.k)] + for item in [(t = t, k = k, + α = float_type(b.self_discharge), + ηc = float_type(b.charge_efficiency) * Δt, + ηd = Δt / float_type(b.discharge_efficiency)) + for t in 1:T for (k, b) in enumerate(batteries)]) + n_con += T * nBat + end + transition_range = transition_start:(transition_start + T * nBat - 1) + + model = ExaModels.ExaModel(core) + prob = BatteryExaProblem(core, model, net, case, batteries, + p_pd, p_qd, p_energy, + zeros(Float64, (T + 1) * nBat), + transition_range, Float64(Δt), stage_of, + T, nB, nG, nBR, nBat) + # Start from the initial energy so a solve before any explicit write is + # still a well-posed problem rather than an all-zero trajectory. + set_energy_path!(prob, + [b.energy_initial for b in batteries], + repeat([b.energy_initial for b in batteries], T)) + return prob +end + +# ───────────────────────────────────────────────────────────────────────────── +# Parameter updates +# ───────────────────────────────────────────────────────────────────────────── + +""" + realized_demand(case, net, stages, atoms) -> (pd, qd) + +Per-bus realized demand matrices for one scenario. + +# Arguments +- `case::BatteryCase`, `net::ExaNetwork`. +- `stages::AbstractVector{<:Integer}`: the ABSOLUTE stage indices, which is what + selects the deterministic shape entry. +- `atoms::AbstractVector{<:Integer}`: realized atom index per stage. + +# Returns +- `(pd, qd)`: two `T×nBus` matrices in pu, indexed by bus POSITION. + +# Notes +The realized demand is read from the FROZEN finite support through the shared +`realized_bus_demand`, which scales each LOAD by its own total multiplier and +then aggregates to the bus. Both matrices carry the same multiplier per load, so +every realization preserves each load's power factor exactly. + +Doing it per load rather than per bus matters as soon as the support is anything +but system-wide: a regional or per-load multiplier applied to a bus AGGREGATE +would already have averaged away the structure the study is about, and the two +engines would then be solving two different problems while both reported "the +same demand". + +Bus POSITION is this engine's own indexing; the shared function returns bus +IDENTIFIERS, and `net.bus_pos` is the only place the two are related. +""" +function realized_demand(case::BatteryCase, net::ExaNetwork, + stages::AbstractVector{<:Integer}, + atoms::AbstractVector{<:Integer}) + length(stages) == length(atoms) || + throw(ArgumentError("stages and atoms must have the same length")) + T = length(stages) + pd = zeros(Float64, T, nbus(net)) + qd = zeros(Float64, T, nbus(net)) + for t in 1:T + bus_pd, bus_qd = realized_bus_demand(case, stages[t], atoms[t]) + for (id, p) in bus_pd + pos = get(net.bus_pos, id, 0) + pos == 0 && continue # a bus this engine dropped (bus_type 4) + pd[t, pos] = p + qd[t, pos] = bus_qd[id] + end + end + return pd, qd +end + +""" + set_demand!(prob, pd, qd) + +Write the realized per-bus demand into the model's parameters. + +# Arguments +- `pd`, `qd`: `T×nBus` matrices in pu, indexed by bus position. +""" +function set_demand!(prob::BatteryExaProblem, pd::AbstractMatrix, qd::AbstractMatrix) + size(pd) == (prob.horizon, prob.nBus) || + error("pd must be $(prob.horizon)×$(prob.nBus), got $(size(pd))") + size(qd) == size(pd) || error("qd must have the same shape as pd") + ExaModels.set_parameter!(prob.core, prob.p_pd, + [pd[t, i] for t in 1:prob.horizon for i in 1:prob.nBus]) + ExaModels.set_parameter!(prob.core, prob.p_qd, + [qd[t, i] for t in 1:prob.horizon for i in 1:prob.nBus]) + return prob +end + +""" + set_energy_path!(prob, x0, xhat) + +Write the strict energy trajectory `[x0; xhat]` into the energy parameter. + +# Arguments +- `x0::AbstractVector`: initial energy per battery, in battery-position order. +- `xhat::AbstractVector`: the `T·nBat` flat, stage-major target trajectory. + +# Notes +This is the ONLY writer of the energy parameter, and it is what maintains the +strict-mode invariant stated at the top of this file: the first `nBat` entries +of the parameter always equal `x0`, because the model has no explicit +initial-condition row to enforce it. +""" +function set_energy_path!(prob::BatteryExaProblem, x0::AbstractVector, xhat::AbstractVector) + prob.nBat == 0 && return prob + length(x0) == prob.nBat || error("x0 must have length nBat=$(prob.nBat)") + length(xhat) == prob.horizon * prob.nBat || + error("xhat must have length T*nBat=$(prob.horizon * prob.nBat)") + vals = vcat(Float64.(vec(Array(x0))), Float64.(vec(Array(xhat)))) + copyto!(prob.energy_values, vals) + ExaModels.set_parameter!(prob.core, prob.p_energy, vals) + return prob +end + +""" + target_multipliers(prob, result) -> Vector{Float64} + +Turn the battery-transition duals into the actor signal +``\\partial Q/\\partial \\hat e_{b,t}``. + +# Notes +Let ``\\mu_{b,t}`` be the multiplier of the transition row + +```math +c_{b,t} := \\hat e_{b,t} - \\alpha_b \\hat e_{b,t-1} + - \\eta^{ch}_b \\Delta t\\, p^{ch}_{b,t} + + \\tfrac{\\Delta t}{\\eta^{dis}_b} p^{dis}_{b,t} = 0 . +``` + +The target ``\\hat e_{b,t}`` appears in row ``t`` with coefficient ``+1`` and in +row ``t+1`` with coefficient ``-\\alpha_b``, and in no other row: the recourse +variables and the network appear in the balance, never in the transition. By the +envelope theorem, + +```math +\\frac{\\partial Q}{\\partial \\hat e_{b,t}} + = \\mu_{b,t} - \\alpha_b \\mu_{b,t+1}, +\\qquad +\\frac{\\partial Q}{\\partial \\hat e_{b,T}} = \\mu_{b,T}. +``` + +The ``\\alpha_b`` factor is not decorative: with a self-discharging battery, the +value of energy left at the end of stage `t` reaches stage `t+1` attenuated, and +dropping it would misprice every interstage trade-off by that factor per stage. +""" +function target_multipliers(prob::BatteryExaProblem, result) + prob.nBat == 0 && return Float64[] + raw = Float64.(vec(Array(result.multipliers))[prob.transition_range]) + nBat, T = prob.nBat, prob.horizon + out = copy(raw) + if T > 1 + for t in 1:(T - 1), k in 1:nBat + out[_bti(nBat, t, k)] -= prob.batteries[k].self_discharge * raw[_bti(nBat, t + 1, k)] + end + end + return out +end + +# ───────────────────────────────────────────────────────────────────────────── +# Solving and extraction +# ───────────────────────────────────────────────────────────────────────────── + +""" + DEFAULT_SOLVER_OPTIONS + +MadNLP options every solve in this engine uses unless the caller overrides them. + +# Notes +The tolerance sits well below every physical tolerance the study reports at. An +interior-point method parks a nonnegative variable roughly one tolerance below +its zero bound, and a positively priced variable sitting there lowers the +objective by a near-constant amount at every stage — an offset that looks +exactly like a systematic model difference when two engines are compared. +""" +const DEFAULT_SOLVER_OPTIONS = (print_level = MadNLP.ERROR, tol = 1e-10) + +""" + solve!(prob; solver_kwargs...) -> result + +Solve the deterministic equivalent with a FRESH MadNLP solver. + +# Notes +A fresh solver per solve, deliberately. MadNLP's re-solve path +(`reinitialize!`) is incompatible with this model as written: PGLib cases +contain synchronous condensers whose active-power box is exactly `[0, 0]`, and +MadNLP's default `fixed_variable_treatment = MakeParameter` removes those +variables from its internal primal vector, after which the re-solve path tries +to broadcast the full-length starting point into the reduced one and raises a +`DimensionMismatch`. The only re-solve configuration that works, +`fixed_variable_treatment = RelaxBound`, widens those boxes to about `1e-8` and +therefore makes this engine's feasible set larger than the PowerModels model it +is validated against — a change to the problem, traded for a constant factor of +speed. Correctness wins: on the correctness-phase case a fresh solve of a +24-stage horizon takes about 0.2 s. +""" +function solve!(prob::BatteryExaProblem; solver_kwargs...) + # `Base.invokelatest` because the GPU linear solver arrives through a + # package EXTENSION that is loaded at run time: a caller that switched to + # the GPU inside a function body is executing in a world older than the + # extension's methods, and MadNLP's option check then reports + # "no method matching input_type(::CUDSSSolver) … the applicable method may + # be too new". The dynamic dispatch is free next to an NLP solve. + return Base.invokelatest(MadNLP.madnlp, prob.model; + DEFAULT_SOLVER_OPTIONS..., solver_kwargs...) +end + +""" + battery_solution(prob, result) -> NamedTuple + +Unpack the flat solution vector into named, positionally indexed components. + +# Notes +The unpacking order MUST match the declaration order in +[`build_battery_exa`](@ref); it is written here as a single sequential walk over +the vector precisely so that the two orders can be read side by side. + +The energy trajectory is not part of the solution vector — it is a parameter — +so it is reported from the last value written, which is the strict-mode +invariant's other half. +""" +function battery_solution(prob::BatteryExaProblem, result) + T, nB, nG, nBR, nBat = prob.horizon, prob.nBus, prob.nGen, prob.nBranch, prob.nBat + sol = Float64.(vec(Array(result.solution))) + off = 0 + take(n) = (v = sol[off .+ (1:n)]; off += n; v) + + va = reshape(take(T * nB), nB, T) + vm = reshape(take(T * nB), nB, T) + pg = reshape(take(T * nG), nG, T) + qg = reshape(take(T * nG), nG, T) + p_fr = reshape(take(T * nBR), nBR, T) + q_fr = reshape(take(T * nBR), nBR, T) + p_to = reshape(take(T * nBR), nBR, T) + q_to = reshape(take(T * nBR), nBR, T) + deficit = reshape(take(T * nB), nB, T) + surplus = reshape(take(T * nB), nB, T) + p_ch = nBat == 0 ? zeros(0, T) : reshape(take(T * nBat), nBat, T) + p_dis = nBat == 0 ? zeros(0, T) : reshape(take(T * nBat), nBat, T) + energy = nBat == 0 ? zeros(0, T + 1) : reshape(copy(prob.energy_values), nBat, T + 1) + + return (va = va, vm = vm, pg = pg, qg = qg, + p_fr = p_fr, q_fr = q_fr, p_to = p_to, q_to = q_to, + deficit = deficit, surplus = surplus, + p_ch = p_ch, p_dis = p_dis, p_bat = p_dis .- p_ch, + energy = energy) +end + +""" + stage_costs(prob, sol) -> NamedTuple + +Decompose the objective into its physical components, per stage. + +# Returns +`(generation, throughput, deficit, surplus, total)`, each a length-`T` vector. + +# Notes +Recomputed from the extracted physical values rather than read off the solver, +so that "the sum of the parts equals the objective" is a real check on both the +extraction order and the objective assembly. +""" +function stage_costs(prob::BatteryExaProblem, sol) + T = prob.horizon + gen = zeros(T); thr = zeros(T); def = zeros(T); sur = zeros(T) + for t in 1:T + for (k, g) in enumerate(prob.net.gens) + p = sol.pg[k, t] + gen[t] += g.c2 * p^2 + g.c1 * p + g.c0 + end + for (k, b) in enumerate(prob.batteries) + thr[t] += b.throughput_cost * prob.Δt * (sol.p_ch[k, t] + sol.p_dis[k, t]) + end + def[t] = prob.case.recourse.deficit * sum(view(sol.deficit, :, t)) + sur[t] = prob.case.recourse.surplus * sum(view(sol.surplus, :, t)) + end + return (generation = gen, throughput = thr, deficit = def, surplus = sur, + total = gen .+ thr .+ def .+ sur) +end diff --git a/examples/BatteryStorageOPF/battery_reachable_policy.jl b/examples/BatteryStorageOPF/battery_reachable_policy.jl new file mode 100644 index 0000000..214f69f --- /dev/null +++ b/examples/BatteryStorageOPF/battery_reachable_policy.jl @@ -0,0 +1,342 @@ +# battery_reachable_policy.jl +# +# The strict TS-DDR policy: a recurrent encoder over the observed demand +# history, a state-conditioned head, and a differentiable affine map from the +# head's bounded output into the battery-dynamic one-stage reachable interval. +# +# Every target this policy emits is reachable BY CONSTRUCTION, which is what +# makes the hard target equality of the stage problem well posed. There is no +# target slack and no target penalty anywhere in this file or in the model it +# feeds. +# +# THE GRADIENT THAT MUST NOT BE TRUNCATED. +# The emitted target is +# +# x̂_t = l_t(e_{t-1}) + (u_t(e_{t-1}) − l_t(e_{t-1})) ⊙ y_t , +# +# and BOTH endpoints depend on the incoming energy with slope α wherever the +# energy bound is not the binding term. In strict mode the incoming energy IS +# the previous stage's emitted target, so +# +# ∂x̂_t/∂e_{t-1} = α (1 − y_t) on coordinates whose lower bound is the +# power-limited one, plus α y_t on those whose +# upper bound is the power-limited one, +# +# is exactly the term that couples the stages. Declaring the reachable bounds +# nondifferentiable truncates the adjoint recursion at EVERY stage, not only +# where a bound binds, and the error compounds with the horizon. The identical +# defect was measured on the hydro study's policy: it left the applied update at +# cosine 0.67 and 6 % of the correct magnitude against finite differences. The +# bounds here are therefore fully differentiable, and only the CONSTANT metadata +# adapters — which merely move frozen numbers onto the right device — are hidden +# from the AD tape. + +using Flux +using Zygote +import DecisionRulesExa: load_stateconditioned_policy! + +""" + stretchedsigmoid(x) -> y ∈ [0, 1 − 1e-3] + +Boundary-attaining squashing function: `clamp((σ(x) − 0.03)/0.94, 0, 1 − 1e-3)`. + +# Notes +A plain sigmoid reaches 0 and 1 only in the limit, so a policy squashed by it +can never place a target exactly at an endpoint of the reachable interval — +which is where an optimal storage decision very often is (charge as hard as +possible, or discharge as hard as possible). The gentle 6.4 % stretch attains +exactly 0 for ``\\sigma(x) \\le 0.03`` while keeping the interior mapping close +to the sigmoid's shape. + +The upper end stops a hair short of 1 on purpose. An exact upper endpoint forces +the charge control to sit exactly at its bound with the discharge control +exactly at zero — a measure-zero face that an interior-point solver cannot +converge into once the strict equality pins the state there. The lower endpoint +has no such problem, because the discharge control retains a strict interior +there, so 0 is attained exactly. +""" +function stretchedsigmoid(x::Real) + T = float(typeof(x)) + return clamp((NNlib.sigmoid(x) - T(0.03)) / T(0.94), zero(T), one(T) - T(1e-3)) +end + +"Activations whose range lies inside [0,1], so the affine map into the reachable interval stays feasible." +const BOUNDED_ACTIVATIONS = (NNlib.sigmoid, NNlib.sigmoid_fast, NNlib.hardsigmoid, stretchedsigmoid) + +""" + BatteryReachablePolicy + +A strict, state-conditioned battery policy. + +# Fields +- `encoder`: recurrent chain over `[context_t; observation_t]`. +- `combiner`: feed-forward head over `[encoded_t; e_{t-1}]`, bounded output. +- `state`: the encoder's recurrent state, threaded across stages explicitly. +- `n_context::Int`: context rows prepended before the observation. +- `n_observation::Int`: observation rows (the observed demand). +- `n_battery::Int`: number of batteries, i.e. the output width. +- `energy_min`, `energy_max`, `charge_gain`, `discharge_drop`, `alpha`: + per-battery reachability metadata (see [`reachable_bounds`](@ref)). + +# Notes +The incoming energy enters TWICE: as an input to the head, and inside the +reachable bounds. Only the second of those couples the stages, and it is the one +an earlier generation of this code got wrong. + +The encoder is recurrent over the observed UNCERTAINTY only; the state does not +enter the recurrent chain. Flux ≥ 0.16 recurrent cells are stateless, so the +state is threaded by hand here — calling the `LSTM` wrapper directly would +silently restart from `initialstates` every stage and produce a MEMORYLESS +encoder that trains, reduces loss, and answers a different question. +""" +mutable struct BatteryReachablePolicy{E,C,RS,V} + encoder::E + combiner::C + state::RS + n_context::Int + n_observation::Int + n_battery::Int + energy_min::V + energy_max::V + charge_gain::V # η^{ch} Δt \overline p^{ch} + discharge_drop::V # Δt \overline p^{dis} / η^{dis} + alpha::V # α, the per-stage retention factor +end + +Flux.@layer BatteryReachablePolicy trainable=(encoder, combiner) + +""" + _adapt_metadata(x, ref) -> AbstractVector + +Return the frozen metadata vector `x` with `ref`'s element type and device. + +# Notes +The returned VALUES are `x`, frozen policy metadata; `ref` contributes only an +element type and a device family. The map is therefore constant in both +arguments and the `Zygote.@nograd` declaration below is EXACT rather than an +approximation. It is needed because the device adaptation goes through +`similar` + `copyto!` and Zygote refuses to differentiate array mutation — +without it the (fully differentiable) reachable bounds could not be traced at +all. This is the ONLY thing hidden from the tape in this file. +""" +function _adapt_metadata(x::AbstractVector, ref::AbstractArray) + typeof(x) === typeof(ref) && return x + y = similar(ref, length(x)) + copyto!(y, convert.(eltype(ref), x)) + return y +end +Zygote.@nograd _adapt_metadata + +""" + reachable_bounds(policy, e_prev, ref) -> (lower, upper) + +Vectorized one-stage reachable interval for every battery. + +# Arguments +- `policy::BatteryReachablePolicy`: carries the frozen reachability metadata. +- `e_prev`: incoming energy, a vector (one scenario) or a matrix (batched, + batteries × scenarios). +- `ref`: array supplying the working element type and device. + +# Returns +- `(lower, upper)`, broadcast-compatible with `e_prev`. + +# Notes +This is the vectorized form of `reachable_interval` in the shared case contract: + +```math +\\underline r = \\max\\{\\underline e,\\; \\alpha e_{t-1} - \\Delta t\\, + \\overline p^{dis}/\\eta^{dis}\\}, +\\qquad +\\overline r = \\min\\{\\overline e,\\; \\alpha e_{t-1} + \\eta^{ch}\\Delta t\\, + \\overline p^{ch}\\}. +``` + +DIFFERENTIABLE in `e_prev`, and that is load-bearing — see the note at the top +of this file. `max`/`min` are subdifferentiable and Zygote's pullback selects the +active branch, which is the correct one-sided derivative away from the kink; the +gradient gate measures the distance to the nearest kink before it differences. + +`upper` is finally clamped from below by `lower`. The two can only cross when +the battery's own bounds are inconsistent with its power ratings, which the case +verifier rejects; the clamp keeps the affine map well defined rather than +papering over data that got that far. +""" +function reachable_bounds(policy::BatteryReachablePolicy, e_prev, ref) + e_min = _adapt_metadata(policy.energy_min, ref) + e_max = _adapt_metadata(policy.energy_max, ref) + gain = _adapt_metadata(policy.charge_gain, ref) + drop = _adapt_metadata(policy.discharge_drop, ref) + α = _adapt_metadata(policy.alpha, ref) + + decayed = α .* e_prev + lower = max.(e_min, decayed .- drop) + upper = min.(e_max, decayed .+ gain) + return lower, max.(upper, lower) +end + +# Row slice that behaves for a vector input (one scenario) and for a matrix +# input (features × scenarios). Plain `input[r]` on a matrix does LINEAR +# indexing and would silently corrupt a batched call. +_row_slice(input::AbstractVector, r) = input[r] +_row_slice(input::AbstractMatrix, r) = input[r, :] + +""" + policy_step(policy, state, input) -> (target, new_state) + +Advance the policy by one stage, PURELY: nothing is mutated. + +# Arguments +- `policy::BatteryReachablePolicy`: the trainable policy. +- `state`: the encoder's recurrent state entering this stage. +- `input`: the concatenation `[context_t; observation_t; e_{t-1}]`, either as a + vector (one scenario) or as a matrix whose columns are scenarios. + +# Returns +- `target`: the outgoing-energy target ``\\hat e_t``, guaranteed to lie in the + one-stage reachable interval. +- `new_state`: the encoder state to carry into stage `t+1`. + +# Notes +This is the form the TRAINER uses. Threading the recurrent state through the +call signature — rather than through a mutable field — keeps the multistage +rollout a pure function of the parameters, which is what lets automatic +differentiation traverse the whole recurrent chain without meeting a mutation it +must either refuse or silently drop. + +The encoder consumes `[context_t; observation_t]` and advances by exactly one +step. The head consumes the encoding together with the incoming energy, and its +bounded output is mapped affinely into the interval returned by +[`reachable_bounds`](@ref). +""" +function policy_step(m::BatteryReachablePolicy, state, input) + o_end = m.n_context + m.n_observation + encoder_input = _row_slice(input, 1:o_end) + e_prev = _row_slice(input, (o_end + 1):size(input, 1)) + + # Cast to the encoder's precision for type stability (mixed precision here + # has previously provoked Zygote codegen failures rather than a slowdown). + T = DecisionRulesExa._state_eltype(state) + h, new_state = DecisionRulesExa._step_encoder(m.encoder, T.(encoder_input), state) + + y = m.combiner(vcat(h, e_prev)) + lower, upper = reachable_bounds(m, e_prev, y) + # `y` is bounded in [0, 1−1e-3], so the image of this affine map is inside + # the reachable interval and the strict equality is always attainable. + return lower .+ (upper .- lower) .* y, new_state +end + +""" + (policy::BatteryReachablePolicy)(input) -> target + +Evaluate the policy, advancing its own recurrent state in place. + +# Notes +The stateful convenience form of [`policy_step`](@ref), for evaluation and +interactive use. Call `Flux.reset!(policy)` at scenario boundaries: failing to +do so leaks one scenario's demand history into the next, and a `reset!` that +silently no-ops leaves the encoder memoryless — a defect that trains, reduces +loss, and answers a different question. The regression tests check that the +state actually changes across a call and actually returns to its initial value +on reset. +""" +function (m::BatteryReachablePolicy)(input) + target, new_state = policy_step(m, m.state, input) + m.state = new_state + return target +end + +""" + Flux.reset!(policy::BatteryReachablePolicy) + +Restore the encoder's recurrent state to `Flux.initialstates`. + +# Notes +The state is re-derived from the (possibly device-moved) encoder weights on +every reset, so it always matches the encoder's device and element type. The +head is feed-forward and carries no state. +""" +function Flux.reset!(m::BatteryReachablePolicy) + m.state = DecisionRulesExa._init_recurrent_state(m.encoder) + return nothing +end + +""" + load_stateconditioned_policy!(policy::BatteryReachablePolicy, state) + +Load checkpointed Flux parameters into a policy, keeping the case's frozen +reachability metadata. + +# Notes +A checkpoint carries the trainable encoder and head only. Reachability metadata +comes from the case, never from a checkpoint: a checkpoint that could override a +battery's rating would let a stale file silently redefine the problem. + +The recurrent state is reset after loading so the next rollout starts from the +loaded weights' own initial state. +""" +function load_stateconditioned_policy!(policy::BatteryReachablePolicy, state) + Flux.loadmodel!(policy, state) + Flux.reset!(policy) + return policy +end + +""" + battery_reachable_policy(case, encoder_layers; n_observation, n_context=0, + head_layers=Int[], activation=stretchedsigmoid, + encoder_type=Flux.LSTM) + -> BatteryReachablePolicy + +Construct a strict reachable policy for a frozen case. + +# Arguments +- `case::BatteryCase`: supplies the batteries and the stage duration. +- `encoder_layers::AbstractVector{Int}`: recurrent encoder widths. + +# Keywords +- `n_observation::Int`: width of the per-stage observation. +- `n_context::Int`: deterministic context rows prepended to the observation. +- `head_layers::AbstractVector{Int}`: hidden widths of the state-conditioned + head. +- `activation`: must be `[0,1]`-bounded; see [`BOUNDED_ACTIVATIONS`](@ref). +- `encoder_type`: recurrent layer constructor. + +# Returns +- A [`BatteryReachablePolicy`](@ref) whose reachability metadata is derived from + the case at CONSTRUCTION, so the policy and the model it feeds cannot disagree + about the battery. +""" +function battery_reachable_policy(case::BatteryCase, encoder_layers::AbstractVector{Int}; + n_observation::Int, + n_context::Int = 0, + head_layers::AbstractVector{Int} = Int[], + activation = stretchedsigmoid, + encoder_type = Flux.LSTM) + any(a -> activation === a, BOUNDED_ACTIVATIONS) || throw(ArgumentError( + "the target head needs a [0,1]-bounded activation so targets stay inside the reachable interval")) + n_context >= 0 || throw(ArgumentError("n_context must be nonnegative")) + n_observation >= 1 || throw(ArgumentError("n_observation must be positive")) + + batteries = sort(collect(case.batteries); by = b -> b.index) + nBat = length(batteries) + Δt = stage_hours(case) + + sizes = vcat(n_context + n_observation, collect(encoder_layers)) + layers = [encoder_type(sizes[i] => sizes[i + 1]) for i in 1:length(encoder_layers)] + encoder = Flux.Chain(layers...) + width = isempty(encoder_layers) ? n_context + n_observation : encoder_layers[end] + combiner = DecisionRulesExa._dense_policy_head(width + nBat, nBat, + collect(Int, head_layers); + activation = activation) + + return BatteryReachablePolicy( + encoder, combiner, + DecisionRulesExa._init_recurrent_state(encoder), + n_context, n_observation, nBat, + Float32[b.energy_min for b in batteries], + Float32[b.energy_max for b in batteries], + Float32[b.charge_efficiency * Δt * b.charge_max for b in batteries], + Float32[Δt * b.discharge_max / b.discharge_efficiency for b in batteries], + Float32[b.self_discharge for b in batteries], + ) +end diff --git a/examples/BatteryStorageOPF/battery_solution_schema.jl b/examples/BatteryStorageOPF/battery_solution_schema.jl new file mode 100644 index 0000000..b18ba0b --- /dev/null +++ b/examples/BatteryStorageOPF/battery_solution_schema.jl @@ -0,0 +1,309 @@ +# battery_solution_schema.jl +# +# The shared, engine-neutral description of a solved battery-storage AC-OPF +# trajectory. This file is shipped BYTE-IDENTICALLY in both public engines, so +# a solution written by the JuMP/PowerModels engine and a solution written by +# the ExaModels engine are the same object and can be differenced by name +# rather than by position. +# +# Format: one long CSV with header +# +# scenario,stage,class,index,value +# +# `class` names a physical quantity (see `SOLUTION_CLASSES`), `index` is the +# NETWORK identifier of the component it belongs to (bus id, generator id, +# branch id, battery id) — never a positional offset — and `value` is a Float64 +# printed with full round-tripping precision. Scalars per stage use index 0. +# +# Why long format and why identifiers. Objective agreement between two engines +# can hide a different feasible set, a null-space variable, or a solver barrier +# offset; only a per-variable comparison catches those, and a per-variable +# comparison is only trustworthy when both sides agree what "variable 7" means. +# Component identifiers in PGLib cases are arbitrary integers and need not be +# consecutive, so positional indexing is not merely fragile — it is wrong. +# +# This file deliberately has no package dependencies beyond `Printf` and the +# standard library: it must be copyable into either engine without dragging a +# resolver conflict behind it. + +using Printf + +""" +Physical classes a battery-storage solution may record. + +Battery-layer classes (index = battery identifier): + +- `"energy_in"` incoming energy ``e_{b,t-1}`` (pu·h) +- `"energy_out"` outgoing energy ``e_{b,t}`` (pu·h) +- `"target"` the strict target ``\\hat e_{b,t}`` (pu·h); absent in the + targetless SDDP formulation +- `"target_dual"` the multiplier ``\\lambda_{b,t}`` of the strict target + equality, i.e. ``\\partial Q/\\partial \\hat e_{b,t}`` +- `"p_ch"` charging power (pu) +- `"p_dis"` discharging power (pu) +- `"p_bat"` net active injection ``p^{dis}-p^{ch}`` (pu) + +Nodal classes (index = bus identifier): + +- `"deficit"` the uncapped nonnegative recourse injection ``d_{i,t}`` (pu) +- `"surplus"` the uncapped nonnegative recourse sink ``s_{i,t}`` (pu) +- `"pd"`, `"qd"` REALIZED active/reactive demand at the bus (pu) +- `"vm"`, `"va"` voltage magnitude (pu) and angle (rad) +- `"pg_bus"`, `"qg_bus"` generation aggregated to the bus (pu) +- `"price_active"`, `"price_reactive"` nodal duals of the balance, where the + engine has them + +Generator classes (index = generator identifier): `"pg"`, `"qg"` (pu). + +Branch classes (index = branch identifier): `"p_fr"`, `"q_fr"`, `"p_to"`, +`"q_to"` (pu, at the respective ends). + +Scalar classes (index 0): + +- `"cost_generation"`, `"cost_throughput"`, `"cost_deficit"`, `"cost_surplus"` +- `"cost_stage"` their sum for the stage +- `"objective"` the engine's own reported stage objective +- `"residual_equality"` worst absolute equality-constraint residual +- `"solved"` 1.0 when the engine accepted the solve, 0.0 otherwise +""" +const SOLUTION_CLASSES = ( + "energy_in", "energy_out", "target", "target_dual", + "p_ch", "p_dis", "p_bat", + "deficit", "surplus", "pd", "qd", "vm", "va", "pg_bus", "qg_bus", + "price_active", "price_reactive", + "pg", "qg", + "p_fr", "q_fr", "p_to", "q_to", + "cost_generation", "cost_throughput", "cost_deficit", "cost_surplus", + "cost_stage", "objective", "residual_equality", "solved", +) + +"Header line of every solution CSV." +const SOLUTION_HEADER = "scenario,stage,class,index,value" + +""" + SolutionRecorder + +Accumulator for solution records in the shared long format. + +# Fields +- `rows::Vector{Tuple{Int,Int,String,Int,Float64}}`: `(scenario, stage, class, + index, value)` in insertion order. + +# Notes +Rows are appended in whatever order an engine produces them; nothing downstream +depends on the order, because comparison is by `(scenario, stage, class, +index)`. Insertion order IS preserved on write so that a diff of two files from +the same engine stays readable. +""" +struct SolutionRecorder + rows::Vector{Tuple{Int,Int,String,Int,Float64}} +end + +SolutionRecorder() = SolutionRecorder(Tuple{Int,Int,String,Int,Float64}[]) + +""" + record!(rec, scenario, stage, class, index, value) + +Append one record, validating the class name. + +# Notes +An unknown class is an ERROR rather than a silently-written row: a typo in a +class name would make the corresponding quantity vanish from a cross-engine +comparison and the comparison would still report "all classes agree". +""" +function record!(rec::SolutionRecorder, scenario::Integer, stage::Integer, + class::AbstractString, index::Integer, value::Real) + class in SOLUTION_CLASSES || error("unknown solution class \"$class\"") + push!(rec.rows, (Int(scenario), Int(stage), String(class), Int(index), Float64(value))) + return rec +end + +""" + record_map!(rec, scenario, stage, class, values::AbstractDict) + +Append one record per `(identifier => value)` pair, in sorted identifier order. +""" +function record_map!(rec::SolutionRecorder, scenario::Integer, stage::Integer, + class::AbstractString, values::AbstractDict) + for k in sort!(collect(keys(values))) + record!(rec, scenario, stage, class, k, values[k]) + end + return rec +end + +""" + write_solution(path, rec::SolutionRecorder) + +Write the accumulated records to `path` in the shared long format. + +# Notes +Values are printed with `%.17g`, which round-trips every `Float64` exactly, so a +cross-engine difference read back from these files is a difference between the +engines and never a difference introduced by printing. +""" +function write_solution(path::AbstractString, rec::SolutionRecorder) + mkpath(dirname(abspath(path))) + open(path, "w") do io + println(io, SOLUTION_HEADER) + for (s, t, c, i, v) in rec.rows + @printf(io, "%d,%d,%s,%d,%.17g\n", s, t, c, i, v) + end + end + return path +end + +""" + physical_residuals(network, batteries, Δt, sol) -> NamedTuple + +Recompute the physics of one solved stage from its reported values and return +the worst violation in each class. + +# Arguments +- `network::AbstractDict`: the frozen PGLib network (per-unit). +- `batteries`: the case's batteries; each must expose `index`, `bus`, + `self_discharge`, `charge_efficiency`, `discharge_efficiency`. +- `Δt::Real`: stage duration in hours. +- `sol`: a named tuple or dictionary exposing, keyed by NETWORK identifier, + `vm`, `va`, `pg`, `qg`, `p_fr`, `q_fr`, `p_to`, `q_to`, `deficit`, `surplus`, + `pd`, `qd`, `p_ch`, `p_dis`, `energy_in`, `energy_out`. + +# Returns +A `NamedTuple` of worst absolute violations: +`(branch_flow, active_balance, reactive_balance, thermal, angle, voltage, + transition)`. + +# Notes +This is deliberately INDEPENDENT of both engines: it re-derives the AC branch +flows from the reported voltages, re-adds the nodal balances from the reported +injections, and re-applies the battery transition to the reported controls. An +engine can therefore be wrong in a way its own solver is happy with and still be +caught here — which is the only kind of check worth running against a manually +written formulation. + +Angles are only meaningful for a polar solution. A solution whose `va` entries +are `NaN` (a W-space relaxation has no angle variable) yields `NaN` in the +branch-flow and angle classes, which is honest rather than silently zero. +""" +function physical_residuals(network::AbstractDict, batteries, Δt::Real, sol) + vm, va = sol.vm, sol.va + worst_flow = 0.0 + worst_thermal = 0.0 + worst_angle = 0.0 + + inj_p = Dict{Int,Float64}(k => 0.0 for k in keys(vm)) + inj_q = Dict{Int,Float64}(k => 0.0 for k in keys(vm)) + + for (_, br) in network["branch"] + Int(get(br, "br_status", 1)) == 0 && continue + l = Int(br["index"]) + haskey(sol.p_fr, l) || continue + f, t = Int(br["f_bus"]), Int(br["t_bus"]) + r, x = Float64(get(br, "br_r", 0.0)), Float64(br["br_x"]) + r2x2 = r^2 + x^2 + g = r2x2 > 0 ? r / r2x2 : 0.0 + b = r2x2 > 0 ? -x / r2x2 : 0.0 + tap = Float64(get(br, "tap", 1.0)); tap = tap ≈ 0 ? 1.0 : tap + shift = Float64(get(br, "shift", 0.0)) + tr, ti = tap * cos(shift), tap * sin(shift) + ttm = tr^2 + ti^2; ttm = ttm > 0 ? ttm : 1.0 + g_fr, b_fr = Float64(get(br, "g_fr", 0.0)), Float64(get(br, "b_fr", 0.0)) + g_to, b_to = Float64(get(br, "g_to", 0.0)), Float64(get(br, "b_to", 0.0)) + + vf, vt = vm[f], vm[t] + θ = va[f] - va[t] + pfr = (g + g_fr) / ttm * vf^2 + (-g * tr + b * ti) / ttm * vf * vt * cos(θ) + + (-b * tr - g * ti) / ttm * vf * vt * sin(θ) + qfr = -(b + b_fr) / ttm * vf^2 - (-b * tr - g * ti) / ttm * vf * vt * cos(θ) + + (-g * tr + b * ti) / ttm * vf * vt * sin(θ) + pto = (g + g_to) * vt^2 + (-g * tr - b * ti) / ttm * vt * vf * cos(-θ) + + (-b * tr + g * ti) / ttm * vt * vf * sin(-θ) + qto = -(b + b_to) * vt^2 - (-b * tr + g * ti) / ttm * vt * vf * cos(-θ) + + (-g * tr - b * ti) / ttm * vt * vf * sin(-θ) + + worst_flow = max(worst_flow, abs(pfr - sol.p_fr[l]), abs(qfr - sol.q_fr[l]), + abs(pto - sol.p_to[l]), abs(qto - sol.q_to[l])) + + rate = Float64(get(br, "rate_a", Inf)) + if isfinite(rate) + worst_thermal = max(worst_thermal, + sol.p_fr[l]^2 + sol.q_fr[l]^2 - rate^2, + sol.p_to[l]^2 + sol.q_to[l]^2 - rate^2) + end + amin = Float64(get(br, "angmin", -pi)); amax = Float64(get(br, "angmax", pi)) + worst_angle = max(worst_angle, amin - θ, θ - amax) + + inj_p[f] -= sol.p_fr[l]; inj_q[f] -= sol.q_fr[l] + inj_p[t] -= sol.p_to[l]; inj_q[t] -= sol.q_to[l] + end + + for (_, gen) in network["gen"] + Int(get(gen, "gen_status", 1)) == 0 && continue + gi = Int(gen["index"]) + haskey(sol.pg, gi) || continue + bus = Int(gen["gen_bus"]) + inj_p[bus] += sol.pg[gi] + inj_q[bus] += sol.qg[gi] + end + + for (_, sh) in get(network, "shunt", Dict{String,Any}()) + Int(get(sh, "status", 1)) == 0 && continue + bus = Int(sh["shunt_bus"]) + haskey(inj_p, bus) || continue + inj_p[bus] -= Float64(get(sh, "gs", 0.0)) * vm[bus]^2 + inj_q[bus] += Float64(get(sh, "bs", 0.0)) * vm[bus]^2 + end + + worst_transition = 0.0 + for b in batteries + haskey(sol.p_ch, b.index) || continue + inj_p[b.bus] += sol.p_dis[b.index] - sol.p_ch[b.index] + lhs = sol.energy_out[b.index] - b.self_discharge * sol.energy_in[b.index] - + b.charge_efficiency * Δt * sol.p_ch[b.index] + + (Δt / b.discharge_efficiency) * sol.p_dis[b.index] + worst_transition = max(worst_transition, abs(lhs)) + end + + worst_p = 0.0 + worst_q = 0.0 + worst_v = 0.0 + for (_, bus) in network["bus"] + i = Int(bus["index"]) + haskey(inj_p, i) || continue + worst_p = max(worst_p, abs(inj_p[i] + sol.deficit[i] - sol.surplus[i] - sol.pd[i])) + worst_q = max(worst_q, abs(inj_q[i] - sol.qd[i])) + worst_v = max(worst_v, Float64(get(bus, "vmin", 0.0)) - vm[i], + vm[i] - Float64(get(bus, "vmax", Inf))) + end + + return (branch_flow = worst_flow, active_balance = worst_p, + reactive_balance = worst_q, thermal = worst_thermal, + angle = worst_angle, voltage = worst_v, transition = worst_transition) +end + +""" + read_solution(path) -> Dict{Tuple{Int,Int,String,Int},Float64} + +Read a solution file into a lookup keyed by `(scenario, stage, class, index)`. + +# Notes +Duplicate keys are an ERROR. Two rows claiming the same physical quantity mean +the writer lost track of what it was recording, and silently keeping the last +one would make a parity comparison depend on file order. +""" +function read_solution(path::AbstractString) + out = Dict{Tuple{Int,Int,String,Int},Float64}() + open(path, "r") do io + header = readline(io) + header == SOLUTION_HEADER || + error("$path: unexpected header \"$header\"; expected \"$SOLUTION_HEADER\"") + for line in eachline(io) + isempty(strip(line)) && continue + parts = split(line, ',') + length(parts) == 5 || error("$path: malformed row \"$line\"") + key = (parse(Int, parts[1]), parse(Int, parts[2]), String(parts[3]), parse(Int, parts[4])) + haskey(out, key) && error("$path: duplicate record for $key") + out[key] = parse(Float64, parts[5]) + end + end + return out +end diff --git a/examples/BatteryStorageOPF/test/runtests.jl b/examples/BatteryStorageOPF/test/runtests.jl new file mode 100644 index 0000000..65ce6cc --- /dev/null +++ b/examples/BatteryStorageOPF/test/runtests.jl @@ -0,0 +1,489 @@ +# Consolidated regression suite for the ExaModels/GPU battery engine. +# +# One file, grouped by the property being protected. The manual ACP formulation +# is checked against the physics (residuals recomputed from the reported +# solution, independently of the model that produced it) and against the case +# contract; its agreement with the actual PowerModels ACP model is checked by a +# separate cross-engine gate outside this package, because only a gate that +# depends on both packages at once can load both engines. +# +# julia --project=. test/runtests.jl +# DR_BAT_DEVICE=gpu julia --project=. test/runtests.jl # additionally on a GPU + +using Test +using Flux +using Zygote +using Random +using Statistics +using LinearAlgebra +using MadNLP +using JLD2 + +const EXAMPLE = dirname(@__DIR__) +include(joinpath(EXAMPLE, "train_battery_exa_strict.jl")) # pulls in the whole engine + +const CASE_DIR = get(ENV, "DR_BAT_CASE_DIR", + joinpath(EXAMPLE, "case", "pglib_opf_case14_ieee")) + +# Cases are CONSTRUCTED by the JuMP package's builder and MIRRORED here; nothing +# under `case/` is committed, because a committed artifact is a second source of +# truth that can drift from the builder that defines it. This engine cannot build +# one — it has no PGLib dependency by design — so it says exactly what to run. +isfile(joinpath(CASE_DIR, "case_manifest.json")) || error(""" +no case at $CASE_DIR. Build and mirror it from the JuMP package first: + + cd /path/to/DecisionRules.jl/examples/BatteryStorageOPF + DR_BAT_MIRROR=$(dirname(EXAMPLE))/$(basename(EXAMPLE)) julia --project=. build_battery_case.jl +""") +const DEVICE = get(ENV, "DR_BAT_DEVICE", "cpu") + +@testset "battery storage OPF (Exa engine)" begin + + case = read_battery_case(CASE_DIR) + net = exa_network(case) + Δt = stage_hours(case) + bats = sort(collect(case.batteries); by = b -> b.index) + nBat = length(bats) + backend, to_device, solver_kwargs = configure_device(DEVICE) + + # ── The network parse ──────────────────────────────────────────────────── + @testset "network parse" begin + @test nbus(net) == length(case.network["bus"]) + @test ngen(net) == count(g -> Int(get(g[2], "gen_status", 1)) != 0, case.network["gen"]) + @test nbranch(net) == count(b -> Int(get(b[2], "br_status", 1)) != 0, case.network["branch"]) + @test !isempty(net.ref_bus_positions) + @test sum(net.nominal_pd) ≈ sum(Float64(l["pd"]) for (_, l) in case.network["load"]) + @test sum(net.nominal_qd) ≈ sum(Float64(l["qd"]) for (_, l) in case.network["load"]) + # Shunts live in their own table and must reach the bus they belong to. + for (_, sh) in get(case.network, "shunt", Dict{String,Any}()) + p = net.bus_pos[Int(sh["shunt_bus"])] + @test net.buses[p].bs != 0.0 || Float64(get(sh, "bs", 0.0)) == 0.0 + end + + # Component identifiers are IDENTITIES, not positions: a case whose bus + # ids are relabelled to a sparse set must parse to the same physics. + relabelled = deepcopy(case.network) + remap = Dict(Int(b["index"]) => 100 * Int(b["index"]) + 7 for (_, b) in case.network["bus"]) + newbus = Dict{String,Any}() + for (_, b) in relabelled["bus"] + b["index"] = remap[Int(b["bus_i"])] + b["bus_i"] = b["index"] + newbus[string(b["index"])] = b + end + relabelled["bus"] = newbus + for (_, g) in relabelled["gen"]; g["gen_bus"] = remap[Int(g["gen_bus"])]; end + for (_, l) in relabelled["load"]; l["load_bus"] = remap[Int(l["load_bus"])]; end + for (_, s) in relabelled["shunt"]; s["shunt_bus"] = remap[Int(s["shunt_bus"])]; end + for (_, br) in relabelled["branch"] + br["f_bus"] = remap[Int(br["f_bus"])] + br["t_bus"] = remap[Int(br["t_bus"])] + end + rcase = BatteryCase(case.dir, case.name, relabelled, + [BatterySpec(b.index, remap[b.bus], b.energy_min, b.energy_max, + b.energy_initial, b.charge_max, b.discharge_max, + b.charge_efficiency, b.discharge_efficiency, + b.self_discharge, b.throughput_cost) for b in bats], + case.recourse, case.demand, case.manifest) + rnet = exa_network(rcase) + @test nbus(rnet) == nbus(net) && ngen(rnet) == ngen(net) && nbranch(rnet) == nbranch(net) + @test rnet.nominal_pd ≈ net.nominal_pd + @test [b.f_pos for b in rnet.branches] == [b.f_pos for b in net.branches] + @test rnet.ref_bus_positions == net.ref_bus_positions + end + + # ── Model structure ────────────────────────────────────────────────────── + @testset "model structure" begin + T = 3 + prob = build_battery_exa(case, T; backend = backend) + nB, nG, nBR = prob.nBus, prob.nGen, prob.nBranch + @test prob.model.meta.nvar == 2T * nB + 2T * nG + 4T * nBR + 2T * nB + 2T * nBat + @test length(prob.transition_range) == T * nBat + @test last(prob.transition_range) == prob.model.meta.ncon # transitions are LAST + + lv = Array(prob.model.meta.lvar); uv = Array(prob.model.meta.uvar) + off = 2T * nB + 2T * nG + 4T * nBR + rng_d = (off + 1):(off + T * nB) + rng_s = (off + T * nB + 1):(off + 2T * nB) + # Two-sided recourse: nonnegative, and uncapped in both directions. + @test all(==(0.0), lv[rng_d]) && all(isinf, uv[rng_d]) + @test all(==(0.0), lv[rng_s]) && all(isinf, uv[rng_s]) + # Charge/discharge respect the case's power ratings. + rng_ch = (off + 2T * nB + 1):(off + 2T * nB + T * nBat) + @test all(==(0.0), lv[rng_ch]) + @test maximum(uv[rng_ch]) ≈ maximum(b.charge_max for b in bats) + @test eltype(prob.model.meta.x0) === Float64 + end + + # ── The strict solve and its multipliers ───────────────────────────────── + @testset "strict solve" begin + T = 3 + prob = build_battery_exa(case, T; backend = backend) + atoms = [3, 1, 2] + pd, qd = realized_demand(case, net, collect(1:T), atoms) + set_demand!(prob, pd, qd) + e0 = initial_energy(case) + + function targets(frac) + xs = Float64[]; prev = copy(e0) + for _ in 1:T + nxt = similar(prev) + for (k, b) in enumerate(bats) + lo, hi = reachable_interval(b, prev[k], Δt) + nxt[k] = lo + frac * (hi - lo) + end + append!(xs, nxt); prev = nxt + end + return xs + end + + x = targets(0.45) + set_energy_path!(prob, e0, x) + # The strict-mode invariant: the parameter's first block IS the initial + # state, because the model has no initial-condition row. + @test prob.energy_values[1:nBat] ≈ e0 + res = solve!(prob; solver_kwargs...) + @test solve_succeeded(res) + sol = battery_solution(prob, res) + cost = stage_costs(prob, sol) + @test sum(cost.total) ≈ res.objective atol = 1e-6 + @test maximum(sol.deficit) < 1e-6 && maximum(sol.surplus) < 1e-6 + @test maximum(min.(sol.p_ch, sol.p_dis)) < 1e-6 # no simultaneous operation + + # The reported trajectory IS the target, exactly: energy is a parameter. + @test vec(sol.energy[:, 2:end]) ≈ x atol = 1e-12 + + # Residuals recomputed independently of the model that produced them. + for t in 1:T + s = (vm = Dict(net.buses[i].id => sol.vm[i, t] for i in eachindex(net.buses)), + va = Dict(net.buses[i].id => sol.va[i, t] for i in eachindex(net.buses)), + pg = Dict(net.gens[i].id => sol.pg[i, t] for i in eachindex(net.gens)), + qg = Dict(net.gens[i].id => sol.qg[i, t] for i in eachindex(net.gens)), + p_fr = Dict(net.branches[i].id => sol.p_fr[i, t] for i in eachindex(net.branches)), + q_fr = Dict(net.branches[i].id => sol.q_fr[i, t] for i in eachindex(net.branches)), + p_to = Dict(net.branches[i].id => sol.p_to[i, t] for i in eachindex(net.branches)), + q_to = Dict(net.branches[i].id => sol.q_to[i, t] for i in eachindex(net.branches)), + deficit = Dict(net.buses[i].id => sol.deficit[i, t] for i in eachindex(net.buses)), + surplus = Dict(net.buses[i].id => sol.surplus[i, t] for i in eachindex(net.buses)), + pd = Dict(net.buses[i].id => pd[t, i] for i in eachindex(net.buses)), + qd = Dict(net.buses[i].id => qd[t, i] for i in eachindex(net.buses)), + p_ch = Dict(bats[k].index => sol.p_ch[k, t] for k in 1:nBat), + p_dis = Dict(bats[k].index => sol.p_dis[k, t] for k in 1:nBat), + energy_in = Dict(bats[k].index => sol.energy[k, t] for k in 1:nBat), + energy_out = Dict(bats[k].index => sol.energy[k, t + 1] for k in 1:nBat)) + r = physical_residuals(case.network, bats, Δt, s) + @test r.branch_flow < 1e-6 + @test r.active_balance < 1e-8 + @test r.reactive_balance < 1e-8 + @test r.transition < 1e-9 + @test r.thermal < 1e-6 + @test r.voltage < 1e-6 + end + + # The multiplier is the derivative of the solved value in the target, + # including the self-discharge factor that couples adjacent rows. + λ = target_multipliers(prob, res) + @test length(λ) == T * nBat + h = 1e-5 + for i in (1, nBat + 2, (T - 1) * nBat + 3) + xp = copy(x); xp[i] += h + xm = copy(x); xm[i] -= h + set_energy_path!(prob, e0, xp) + vp = solve!(prob; solver_kwargs...).objective + set_energy_path!(prob, e0, xm) + vm_ = solve!(prob; solver_kwargs...).objective + @test (vp - vm_) / (2h) ≈ λ[i] rtol = 1e-4 + end + end + + # ── A generator that exists in some stages and not others ──────────────── + # The case may declare a per-stage availability schedule for any generator + # (`STAGE_AVAILABILITY_KEY`). The JuMP engine applies it to the parsed network + # before PowerModels instantiates each stage; this engine builds every stage + # at once, so it applies it to each stage's generator BOUNDS instead. The + # failure this guards against is silence: a schedule that is written into a + # case, hashed and mirrored here, and then ignored by the model builder, would + # give this engine a generator that is always available while the JuMP engine, + # the case record and the digest all say otherwise — two engines solving two + # different problems, which is the one thing this suite exists to prevent. + @testset "per-stage generator availability" begin + # ── Additivity: the frozen case declares no schedule ────────────────── + # A case built before this convention existed must build EXACTLY as it + # did then: one `repeat` of the case's own limits per stage, compared + # bit-for-bit rather than approximately. + @test all(isempty(g.availability) for g in net.gens) + T = 2 + plain = build_battery_exa(case, T; backend = backend) + off_p = 2T * nbus(net) + off_q = off_p + T * ngen(net) + plv = Array(plain.model.meta.lvar); puv = Array(plain.model.meta.uvar) + @test plv[(off_p + 1):(off_p + T * ngen(net))] == + repeat([g.pmin for g in net.gens], T) + @test puv[(off_p + 1):(off_p + T * ngen(net))] == + repeat([g.pmax for g in net.gens], T) + @test plv[(off_q + 1):(off_q + T * ngen(net))] == + repeat([isfinite(g.qmin) ? g.qmin : -1e4 for g in net.gens], T) + @test puv[(off_q + 1):(off_q + T * ngen(net))] == + repeat([isfinite(g.qmax) ? g.qmax : 1e4 for g in net.gens], T) + + # ── The fixture ─────────────────────────────────────────────────────── + # An in-memory case whose generator `gid` is FREE to run and carries the + # schedule `av`. Nothing is written to disk: the schedule is network data, + # and a test that had to run the JuMP builder could not run in this + # environment at all. + # + # The unit is made free rather than picked for being dispatched, so that + # the always-available twin further down is a decisive null control by + # construction: a zero-cost unit runs unless something stops it, so a + # stage-2 output of exactly zero can only be the schedule. Picking a unit + # by its dispatch would make the control depend on the frozen case's + # economics, which is not what is being tested here. + refbuses = Set(net.buses[p].id for p in net.ref_bus_positions) + cands = [i for (i, g) in enumerate(net.gens) + if !(net.buses[g.bus_pos].id in refbuses)] + @test !isempty(cands) + gpos = cands[argmax([net.gens[i].pmax for i in cands])] + GID = net.gens[gpos].id + + function fixture(av; free::Bool = true) + netj = deepcopy(case.network) + g = netj["gen"][string(GID)] + if free + g["model"] = 2; g["ncost"] = 2; g["cost"] = [0.0, 0.0] + end + av === nothing ? delete!(g, STAGE_AVAILABILITY_KEY) : + (g[STAGE_AVAILABILITY_KEY] = av) + return BatteryCase(case.dir, case.name, netj, case.batteries, + case.recourse, case.demand, case.manifest) + end + + base = build_battery_exa(fixture(nothing), T; backend = backend) + fnet = exa_network(fixture(nothing)) + gsel = fnet.gens[gpos] + @test gsel.id == GID + lv = Array(base.model.meta.lvar); uv = Array(base.model.meta.uvar) + + # ── What the parser refuses ─────────────────────────────────────────── + @test_throws ErrorException exa_network(fixture(Float64[])) + @test_throws ErrorException exa_network(fixture(1.0)) + @test_throws ErrorException exa_network(fixture([1.0, 1.5])) + @test_throws ErrorException exa_network(fixture([1.0, -0.5])) + @test_throws ErrorException exa_network(fixture([1.0, NaN])) + # Inconsistent bounds are checked where the new data is read. + badb = fixture([1.0, 0.0]) + badb.network["gen"][string(GID)]["pmin"] = Float64(gsel.pmax) + 1.0 + @test_throws ErrorException exa_network(badb) + + # ── Scaling is per stage, and covers reactive as well as active ─────── + sched = fixture([1.0, 0.0]) + snet = exa_network(sched) + @test snet.gens[gpos].availability == [1.0, 0.0] + @test availability_at(snet.gens[gpos], 1) == 1.0 + @test availability_at(snet.gens[gpos], 2) == 0.0 + sprob = build_battery_exa(sched, T; backend = backend) + # The model's SHAPE does not depend on the schedule. + @test sprob.model.meta.nvar == base.model.meta.nvar + @test sprob.model.meta.ncon == base.model.meta.ncon + slv = Array(sprob.model.meta.lvar); suv = Array(sprob.model.meta.uvar) + nG = ngen(net) + p1 = off_p + gpos; p2 = off_p + nG + gpos + q1 = off_q + gpos; q2 = off_q + nG + gpos + @test slv[p1] == gsel.pmin && suv[p1] == gsel.pmax # stage 1: untouched + @test slv[p2] == 0.0 && suv[p2] == 0.0 # stage 2: exactly out + @test slv[q2] == 0.0 && suv[q2] == 0.0 + @test slv[q1] == lv[q1] && suv[q1] == uv[q1] + # Every other generator, in both stages, is exactly as it was. + for i in 1:(T * nG) + (i == gpos || i == nG + gpos) && continue + @test slv[off_p + i] == lv[off_p + i] && suv[off_p + i] == uv[off_p + i] + @test slv[off_q + i] == lv[off_q + i] && suv[off_q + i] == uv[off_q + i] + end + # A schedule of all ones is the null control for that zero: same case, + # same unit, and bounds identical to the unscheduled build. + ones_prob = build_battery_exa(fixture([1.0, 1.0]), T; backend = backend) + @test Array(ones_prob.model.meta.lvar) == lv + @test Array(ones_prob.model.meta.uvar) == uv + + # ── A stage the schedule does not cover is an error, never the last ─── + @test_throws ErrorException build_battery_exa(sched, 3; backend = backend) + @test_throws ErrorException build_battery_exa(sched, 1; backend = backend, + stages = [3]) + + # ── A WINDOW of the horizon reads that window's entry ───────────────── + # A continuation problem is the case's stage 2 solved on its own, and it + # must see stage 2's availability, not the first entry of the schedule. + w2 = build_battery_exa(sched, 1; backend = backend, stages = [2]) + @test w2.stages == [2] + @test Array(w2.model.meta.lvar)[2 * nbus(net) + gpos] == 0.0 + @test Array(w2.model.meta.uvar)[2 * nbus(net) + gpos] == 0.0 + w1 = build_battery_exa(sched, 1; backend = backend, stages = [1]) + @test Array(w1.model.meta.uvar)[2 * nbus(net) + gpos] == gsel.pmax + # And the window is enforced at the solve site rather than assumed: a + # scheduled problem refuses an offset it was not built for, while an + # unscheduled one accepts every offset exactly as it always did. + @test assert_stage_window(sprob, [1, 2]) === nothing + @test_throws ErrorException assert_stage_window(sprob, [2, 3]) + @test assert_stage_window(base, [2, 3]) === nothing + @test !has_stage_schedule(base) && has_stage_schedule(sprob) + + # ── What it DISPATCHES ──────────────────────────────────────────────── + # One demand realization, one strict trajectory, imposed on the scheduled + # problem and on its always-available twin. The schedule is the only + # difference between the two. + atoms = [1, 2] + pd2, qd2 = realized_demand(sched, snet, collect(1:T), atoms) + e0 = initial_energy(sched) + xs = Float64[]; prev = copy(e0) + for _ in 1:T + nxt = similar(prev) + for (k, b) in enumerate(bats) + lo, hi = reachable_interval(b, prev[k], Δt) + nxt[k] = lo + 0.5 * (hi - lo) + end + append!(xs, nxt); prev = nxt + end + set_demand!(sprob, pd2, qd2); set_energy_path!(sprob, e0, xs) + sres = solve!(sprob; solver_kwargs...) + @test solve_succeeded(sres) + ssol = battery_solution(sprob, sres) + @test abs(ssol.pg[gpos, 2]) <= 1e-9 # the schedule's own property + @test abs(ssol.qg[gpos, 2]) <= 1e-9 + # The null control dispatches the same unit in the same stage without it. + set_demand!(ones_prob, pd2, qd2); set_energy_path!(ones_prob, e0, xs) + ores = solve!(ones_prob; solver_kwargs...) + @test solve_succeeded(ores) + osol = battery_solution(ones_prob, ores) + @test abs(osol.pg[gpos, 2]) > 1e-6 + + # ── The schedule is DATA, not a differentiable path ─────────────────── + # It reaches the model through variable bounds only, so the trajectory + # derivative the trainer consumes is still exactly the derivative of the + # solved value — checked here against central differences on the case + # that carries the schedule. + λ = target_multipliers(sprob, sres) + @test length(λ) == T * nBat + @test all(isfinite, λ) + h = 1e-5 + for i in (1, nBat + 1) + xp = copy(xs); xp[i] += h + xm = copy(xs); xm[i] -= h + set_energy_path!(sprob, e0, xp) + vp = solve!(sprob; solver_kwargs...).objective + set_energy_path!(sprob, e0, xm) + vm_ = solve!(sprob; solver_kwargs...).objective + @test (vp - vm_) / (2h) ≈ λ[i] rtol = 1e-4 + end + end + + # ── The strict reachable policy ────────────────────────────────────────── + @testset "reachable policy" begin + Random.seed!(11) + prob = build_battery_exa(case, 4; backend = backend) + policy = to_device(battery_reachable_policy(case, [8]; + n_observation = prob.nBus, n_context = N_CONTEXT, + head_layers = [12])) + assert_device(policy, DEVICE) + @test_throws ArgumentError battery_reachable_policy(case, [8]; + n_observation = prob.nBus, activation = tanh) + + like = _policy_array(policy) + e0 = initial_energy(case) + e0d = _to_like(like, e0) + atoms = [1, 3, 2, 2] + features = rollout_features(case, prob.net, atoms; like = like) + + # The vectorized bounds agree with the shared case contract's scalar form. + lo, hi = reachable_bounds(policy, e0d, e0d) + for (k, b) in enumerate(bats) + l, u = reachable_interval(b, e0[k], Δt) + @test Float64(Array(lo)[k]) ≈ l atol = 1e-5 + @test Float64(Array(hi)[k]) ≈ u atol = 1e-5 + end + + # Every emitted target lies inside its own reachable interval. + x = Float64.(vec(Array(rollout_targets(policy, features, e0d)))) + prev = copy(e0) + for t in 1:4 + for (k, b) in enumerate(bats) + l, u = reachable_interval(b, prev[k], Δt) + @test l - 1e-5 <= x[(t - 1) * nBat + k] <= u + 1e-5 + end + prev = x[((t - 1) * nBat + 1):(t * nBat)] + end + + # The recurrent state really advances, and `reset!` really resets it. + Flux.reset!(policy) + s0 = deepcopy(policy.state) + policy(vcat(features[:, 1], e0d)) + @test !isapprox(Float64.(vec(Array(policy.state[1][1]))), + Float64.(vec(Array(s0[1][1]))); atol = 1e-12) + Flux.reset!(policy) + @test Float64.(vec(Array(policy.state[1][1]))) ≈ Float64.(vec(Array(s0[1][1]))) + + # A repeated rollout of the SAME scenario reproduces itself exactly, + # which is only true if the boundary reset actually happens. + x2 = Float64.(vec(Array(rollout_targets(policy, features, e0d)))) + @test x2 == x + # A DIFFERENT scenario must produce a different trajectory — otherwise + # the encoder is memoryless and the policy is not reading the demand. + alt = rollout_features(case, prob.net, [3, 1, 1, 3]; like = like) + @test !isapprox(Float64.(vec(Array(rollout_targets(policy, alt, e0d)))), x; atol = 1e-8) + + # The gradient flows through the reachable bounds. Holding the head + # output fixed, the target still moves with the incoming energy, so a + # derivative taken with the bounds detached is strictly smaller. + λ = _to_like(like, ones(4 * nBat)) + _, g_full = actor_gradient(policy, features, λ, e0d) + gvec = Float64[] + Flux.fmap(x -> (x isa AbstractArray && append!(gvec, Float64.(vec(Array(x)))); x), g_full) + @test any(!iszero, gvec) + @test all(isfinite, gvec) + end + + # ── Checkpoints ────────────────────────────────────────────────────────── + @testset "checkpoint round trip" begin + Random.seed!(3) + prob = build_battery_exa(case, 3; backend = backend) + policy = to_device(battery_reachable_policy(case, [6]; + n_observation = prob.nBus, n_context = N_CONTEXT, + head_layers = [8])) + like = _policy_array(policy) + e0d = _to_like(like, initial_energy(case)) + features = rollout_features(case, prob.net, [2, 1, 3]; like = like) + before = Float64.(vec(Array(rollout_targets(policy, features, e0d)))) + + path = joinpath(mktempdir(), "ckpt.jld2") + save_checkpoint(path, policy, Dict( + "case" => case.name, + "network_sha256" => case.manifest["artifacts"]["network.json"])) + + fresh = to_device(battery_reachable_policy(case, [6]; + n_observation = prob.nBus, n_context = N_CONTEXT, + head_layers = [8])) + @test !isapprox(Float64.(vec(Array(rollout_targets(fresh, features, e0d)))), before; atol = 1e-8) + meta = load_checkpoint!(fresh, path; case = case) + @test meta["case"] == case.name + # Exact reproduction, not merely close: the reload must be the policy. + @test Float64.(vec(Array(rollout_targets(fresh, features, e0d)))) == before + + # A checkpoint from a different case is refused rather than mismatched. + bad = joinpath(mktempdir(), "bad.jld2") + save_checkpoint(bad, policy, Dict("case" => "other", "network_sha256" => "deadbeef")) + @test_throws ErrorException load_checkpoint!(fresh, bad; case = case) + end + + # ── Training performs real updates ─────────────────────────────────────── + @testset "training smoke" begin + out = train_strict(; case_dir = CASE_DIR, num_stages = 4, epochs = 1, batches = 2, + trajectories = 1, encoder_layers = [8], head_layers = [12], + eval_every = 2, eval_columns = [1, 2], device = DEVICE, + checkpoint = joinpath(mktempdir(), "smoke.jld2"), verbose = false) + @test out.updates == 2 + @test length(out.history) == 2 + @test all(isfinite(h.loss) for h in out.history) + # The learning-rate schedule is a declared function of the step index. + @test out.history[1].lr > out.history[end].lr + # A complete panel evaluation selected a checkpoint. + @test isfinite(out.best.cost) + @test isfile(out.checkpoint) + end +end diff --git a/examples/BatteryStorageOPF/train_battery_exa_strict.jl b/examples/BatteryStorageOPF/train_battery_exa_strict.jl new file mode 100644 index 0000000..a1ec9a1 --- /dev/null +++ b/examples/BatteryStorageOPF/train_battery_exa_strict.jl @@ -0,0 +1,617 @@ +# train_battery_exa_strict.jl +# +# The single, fully parameterized strict TS-DDR training entry point for the +# battery study, plus the rollout and evaluation machinery it shares with the +# correctness gates. +# +# THE ACTOR GRADIENT, in one paragraph. +# The policy emits a strict, one-stage reachable target trajectory +# ``\hat e(\theta)``; the deterministic equivalent solves the true-ACP stage +# problems with the outgoing energy pinned to it, and returns the multipliers +# ``\lambda`` of the battery state transitions. By the envelope theorem the +# derivative of the solved value with respect to the trajectory is exactly +# ``\lambda``, so +# +# ∇_θ Q(w; \hat e(θ)) = Σ_t λ_t ∇_θ \hat e_t(θ), +# +# and the update is obtained by differentiating the surrogate ⟨λ, ê(θ)⟩ with λ +# HELD CONSTANT. The whole recurrent chain — encoder memory, head, and the +# reachable bounds' dependence on the previous target — is inside that +# differentiation. Nothing is detached. +# +# Usage +# julia --project=. -t auto train_battery_exa_strict.jl +# +# Environment (all optional): +# DR_BAT_CASE_DIR frozen case directory +# DR_BAT_STAGES horizon T (default 24) +# DR_BAT_EPOCHS number of epochs (default 2) +# DR_BAT_BATCHES gradient steps per epoch (default 5) +# DR_BAT_TRAJ trajectories per gradient step (default 2) +# DR_BAT_LR initial learning rate (default 1e-3) +# DR_BAT_LR_FINAL final learning rate of the cosine ramp (default 1e-4) +# DR_BAT_ENCODER encoder widths, comma separated (default 64,64) +# DR_BAT_HEAD head widths, comma separated (default 128,128) +# DR_BAT_EVAL_EVERY gradient steps between panel evaluations (default 5) +# DR_BAT_EVAL_COLS protocol columns forming the panel (default 1,2,3,4) +# DR_BAT_SEED training seed (default 20260804) +# DR_BAT_DEVICE "cpu" or "gpu" (default cpu) +# DR_BAT_MAX_RECOURSE physical admissibility tolerance, pu (default 1e-6) +# DR_BAT_CHECKPOINT checkpoint path + +using Flux +using Zygote +using Optimisers +using JLD2 +using Random +using StableRNGs +using Statistics +using Printf +using LinearAlgebra +using DecisionRulesExa + +include(joinpath(@__DIR__, "battery_case.jl")) +include(joinpath(@__DIR__, "battery_solution_schema.jl")) +include(joinpath(@__DIR__, "battery_exa.jl")) +include(joinpath(@__DIR__, "battery_reachable_policy.jl")) + +# ───────────────────────────────────────────────────────────────────────────── +# Observation and context +# ───────────────────────────────────────────────────────────────────────────── + +""" + stage_context(case, t) -> Vector{Float64} + +Deterministic per-stage context the policy is allowed to see. + +# Notes +The pair ``(\\sin 2\\pi t/P, \\cos 2\\pi t/P)`` for the deterministic profile's +period ``P``, which the frozen support records. It encodes the position in the daily cycle without a discontinuity at +midnight, which a raw hour index would introduce. This is DETERMINISTIC +information — knowing the clock is not knowing the future demand — so it does +not violate nonanticipativity. +""" +function stage_context(case::BatteryCase, t::Integer) + P = profile_period(case.demand) + θ = 2π * (t - 1) / P + return [sin(θ), cos(θ)] +end + +"Width of the context block." +const N_CONTEXT = 2 + +""" + stage_observation(net, case, t, atom) -> Vector{Float64} + +The observation revealed at the beginning of stage `t`: the realized per-bus +ACTIVE demand (pu), indexed by bus position. + +# Notes +Reactive demand carries no extra information — every load is scaled by the same +multiplier on both sides, because the process preserves each load's power factor +— so feeding it would double the input width for nothing. +""" +function stage_observation(net::ExaNetwork, case::BatteryCase, t::Integer, atom::Integer) + pd, _ = realized_demand(case, net, [t], [atom]) + return vec(pd) +end + +# ───────────────────────────────────────────────────────────────────────────── +# Rollout +# ───────────────────────────────────────────────────────────────────────────── + +""" + rollout_features(case, net, atoms; stage_offset=0, like) -> AbstractMatrix + +Build the `(n_context + n_observation) × T` matrix of policy inputs that do NOT +depend on the policy: the deterministic context and the revealed demand. + +# Keywords +- `like::AbstractArray`: array supplying the element type and device the matrix + must land on. + +# Notes +These features are constants of the rollout. Building them OUTSIDE the +differentiated region matters for two reasons: it keeps the host-to-device copy +(a mutation, which automatic differentiation refuses to trace) off the tape, and +it makes explicit that nothing in the observation depends on the parameters. +""" +function rollout_features(case::BatteryCase, net::ExaNetwork, + atoms::AbstractVector{<:Integer}; + stage_offset::Integer = 0, + like::AbstractArray) + T = length(atoms) + cols = [vcat(stage_context(case, stage_offset + i), + stage_observation(net, case, stage_offset + i, atoms[i])) for i in 1:T] + host = reduce(hcat, cols) + device = similar(like, size(host)...) + copyto!(device, eltype(like).(host)) + return device +end + +""" + rollout_targets(policy, features, e0) -> AbstractVector + +Roll the policy forward over a scenario and return the flat, stage-major target +trajectory ``[\\hat e_1; \\ldots; \\hat e_T]``. + +# Arguments +- `policy::BatteryReachablePolicy`. +- `features::AbstractMatrix`: the per-stage inputs from + [`rollout_features`](@ref); column `i` is stage `i`. +- `e0::AbstractVector`: initial energy, in battery-position order. + +# Returns +- A vector of length `T·nBat`, differentiable in the policy parameters. + +# Notes +The recurrent state starts from `Flux.initialstates` — the scenario boundary — +and is threaded explicitly through [`policy_step`](@ref), and the emitted target +of stage `t` becomes the incoming energy of stage `t+1`. That feedback is what +makes this a genuinely multistage policy, and it is precisely the path along +which the reachable bounds' dependence on the incoming energy carries gradient. + +The trajectory is accumulated in a `Zygote.Buffer` so the loop stays type-stable +and still differentiable; a plain array write would be a mutation Zygote +refuses. +""" +function rollout_targets(policy::BatteryReachablePolicy, features::AbstractMatrix, + e0::AbstractVector) + T = size(features, 2) + nBat = policy.n_battery + state = DecisionRulesExa._init_recurrent_state(policy.encoder) + e_prev = e0 + buf = Zygote.Buffer(similar(e0, T * nBat)) + for i in 1:T + target, state = policy_step(policy, state, vcat(features[:, i], e_prev)) + buf[((i - 1) * nBat + 1):(i * nBat)] = target + e_prev = target + end + return copy(buf) +end + +""" + initial_energy(case) -> Vector{Float64} + +The frozen initial energy of every battery, in battery-position order. +""" +initial_energy(case::BatteryCase) = + Float64[b.energy_initial for b in sort(collect(case.batteries); by = b -> b.index)] + +# ───────────────────────────────────────────────────────────────────────────── +# One solve of the strict deterministic equivalent +# ───────────────────────────────────────────────────────────────────────────── + +""" + strict_solve!(prob, case, atoms, targets; stage_offset=0, solver_kwargs=NamedTuple()) + -> (result, solution, λ) + +Impose one scenario and one target trajectory on the deterministic equivalent, +solve it, and return the solution together with the actor signal. + +# Notes +`λ` is [`target_multipliers`](@ref)'s output: ``\\partial Q/\\partial \\hat e``, +already carrying the ``\\alpha`` correction that links consecutive transition +rows. + +The scenario and the targets are written into the model's PARAMETERS, so the +model itself — its sparsity pattern, its derivative kernels — is built once and +reused for the whole run; only the solver instance is fresh, for the reason +documented on [`solve!`](@ref). +""" +function strict_solve!(prob::BatteryExaProblem, case::BatteryCase, + atoms::AbstractVector{<:Integer}, targets::AbstractVector; + stage_offset::Integer = 0, + solver_kwargs = NamedTuple()) + stages = collect((stage_offset + 1):(stage_offset + prob.horizon)) + # Demand is a parameter and may be re-imposed for any window; per-stage + # generator availability is in the bounds and may not. See + # [`assert_stage_window`](@ref) — a case with no schedule accepts every offset. + assert_stage_window(prob, stages) + pd, qd = realized_demand(case, prob.net, stages, collect(atoms)) + set_demand!(prob, pd, qd) + set_energy_path!(prob, initial_energy(case), Float64.(vec(Array(targets)))) + result = solve!(prob; solver_kwargs...) + return result, battery_solution(prob, result), target_multipliers(prob, result) +end + +# ───────────────────────────────────────────────────────────────────────────── +# Evaluation +# ───────────────────────────────────────────────────────────────────────────── + +""" + evaluate_panel(policy, prob, case, columns; protocol_stages, protocol_scenarios, + max_recourse) -> NamedTuple + +Evaluate the policy on a fixed panel of paired protocol columns. + +# Returns +`(mean_cost, costs, worst_recourse, complete)`. + +# Notes +The panel is FIXED and comes from the frozen protocol, so its columns mean the +same demand paths for every checkpoint and for the SDDP baseline. Checkpoint +selection uses this panel and nothing else — never the training loss, whose +sample size changes between phases, and never the final paired protocol, which +is evaluated once after selection. + +An evaluation is COMPLETE only if every column solved and the worst physical +recourse on every column is within `max_recourse`. An incomplete evaluation is +invalid: averaging the columns that happened to succeed would report a policy +that does not exist. +""" +function evaluate_panel(policy::BatteryReachablePolicy, prob::BatteryExaProblem, + case::BatteryCase, columns::AbstractVector{<:Integer}; + protocol_stages::Integer, protocol_scenarios::Integer, + max_recourse::Real = 1e-6, solver_kwargs = NamedTuple()) + matrix = scenario_index_matrix(case.demand, protocol_stages, protocol_scenarios) + e0 = initial_energy(case) + costs = Float64[] + worst = 0.0 + complete = true + like = _policy_array(policy) + for c in columns + atoms = matrix[1:prob.horizon, c] + features = rollout_features(case, prob.net, atoms; like = like) + targets = rollout_targets(policy, features, _to_like(like, e0)) + result, sol, _ = strict_solve!(prob, case, atoms, targets; + solver_kwargs = solver_kwargs) + if !solve_succeeded(result) + complete = false + continue + end + rec = max(maximum(sol.deficit; init = 0.0), maximum(sol.surplus; init = 0.0)) + worst = max(worst, rec) + push!(costs, sum(stage_costs(prob, sol).total)) + end + complete &= (length(costs) == length(columns)) && (worst <= max_recourse) + return (mean_cost = isempty(costs) ? NaN : mean(costs), costs = costs, + worst_recourse = worst, complete = complete) +end + +# ───────────────────────────────────────────────────────────────────────────── +# Training +# ───────────────────────────────────────────────────────────────────────────── + +""" + actor_gradient(policy, features, λ, e0) -> (value, gradient) + +Differentiate the surrogate ``\\langle \\lambda, \\hat e(\\theta)\\rangle`` +through the complete recurrent reachable policy. + +# Returns +- `value`: the surrogate's value. +- `gradient`: the gradient tree with respect to the policy's parameters. + +# Notes +`λ` enters as a CONSTANT: it is the envelope-theorem derivative of the solved +stage value, already evaluated at this trajectory, so differentiating it again +would double-count the stage problem's response. + +Everything else IS differentiated: the encoder's recurrent chain, the head, the +affine map into the reachable interval, and — critically — the interval's own +dependence on the incoming energy, which is the previous stage's target. +""" +function actor_gradient(policy::BatteryReachablePolicy, features::AbstractMatrix, + λ::AbstractVector, e0::AbstractVector) + out = Flux.withgradient(policy) do m + sum(λ .* rollout_targets(m, features, e0)) + end + return out.val, out.grad[1] +end + +""" + sample_atoms(rng, case, T) -> Vector{Int} + +Draw one training scenario: `T` independent atom indices, each from its own +stage's frozen support. +""" +function sample_atoms(rng, case::BatteryCase, T::Integer) + # Per STAGE: the frozen support is stage-dependent in general, so one shared + # probability vector would sample the wrong distribution on any case whose + # late stages carry a different support. + return [begin + p = cumsum(atom_probabilities(case.demand, t)) + searchsortedfirst(p, rand(rng)) + end for t in 1:T] +end + +""" + cosine_lr(step, total, lr0, lr1) -> Float64 + +Cosine ramp from `lr0` to `lr1` over `total` steps. + +# Notes +Declared as a function of the step index rather than carried as optimizer state, +so a run that is interrupted and resumed follows the same schedule it would have +followed uninterrupted. +""" +function cosine_lr(step::Integer, total::Integer, lr0::Real, lr1::Real) + total <= 1 && return Float64(lr1) + x = clamp((step - 1) / (total - 1), 0.0, 1.0) + return lr1 + 0.5 * (lr0 - lr1) * (1 + cos(π * x)) +end + +""" + save_checkpoint(path, policy, meta) + +Write the policy's trainable state and its metadata to `path`. + +# Notes +Only `Flux.state(policy)` is written. Reachability metadata is deliberately NOT +part of the checkpoint: it belongs to the frozen case, and a checkpoint that +could override a battery rating would let a stale file silently redefine the +problem it was trained on. The case's manifest hash is recorded instead, so a +reload against a different case FAILS rather than quietly mismatching. +""" +function save_checkpoint(path::AbstractString, policy::BatteryReachablePolicy, meta::AbstractDict) + mkpath(dirname(abspath(path))) + JLD2.jldsave(path; state = Flux.state(Flux.cpu(policy)), meta = Dict(meta)) + return path +end + +""" + load_checkpoint!(policy, path; case=nothing) -> Dict + +Load a checkpoint into `policy`, verifying it belongs to the case in hand. +""" +function load_checkpoint!(policy::BatteryReachablePolicy, path::AbstractString; + case::Union{Nothing,BatteryCase} = nothing) + data = JLD2.load(path) + meta = data["meta"] + if case !== nothing && haskey(meta, "network_sha256") + want = case.manifest["artifacts"]["network.json"] + meta["network_sha256"] == want || error( + "checkpoint $path was trained on network $(meta["network_sha256"]) but the case in hand is $want") + end + load_stateconditioned_policy!(policy, data["state"]) + return meta +end + +""" + train_strict(; kwargs...) -> NamedTuple + +Run one parameterized strict TS-DDR training stage. + +# Notes +One gradient step is: draw `trajectories` scenarios, roll the policy forward on +each, solve each strict deterministic equivalent, average the per-trajectory +actor gradients, and apply one Adam step at the scheduled learning rate. A small +sample gives a noisy but cheap gradient, which is what bulk descent wants; a +large one gives a precise gradient, which is what final convergence wants. + +Checkpoints are written only when a COMPLETE panel evaluation improves on the +best complete evaluation so far, so a policy that leans on physical recourse can +never become the selected one. +""" +function train_strict(; case_dir::AbstractString = get(ENV, "DR_BAT_CASE_DIR", + joinpath(@__DIR__, "case", "pglib_opf_case14_ieee")), + num_stages::Integer = parse(Int, get(ENV, "DR_BAT_STAGES", "24")), + epochs::Integer = parse(Int, get(ENV, "DR_BAT_EPOCHS", "2")), + batches::Integer = parse(Int, get(ENV, "DR_BAT_BATCHES", "5")), + trajectories::Integer = parse(Int, get(ENV, "DR_BAT_TRAJ", "2")), + lr::Real = parse(Float64, get(ENV, "DR_BAT_LR", "1e-3")), + lr_final::Real = parse(Float64, get(ENV, "DR_BAT_LR_FINAL", "1e-4")), + encoder_layers = _env_ints("DR_BAT_ENCODER", [64, 64]), + head_layers = _env_ints("DR_BAT_HEAD", [128, 128]), + eval_every::Integer = parse(Int, get(ENV, "DR_BAT_EVAL_EVERY", "5")), + eval_columns = _env_ints("DR_BAT_EVAL_COLS", [1, 2, 3, 4]), + seed::Integer = parse(Int, get(ENV, "DR_BAT_SEED", "20260804")), + device::AbstractString = get(ENV, "DR_BAT_DEVICE", "cpu"), + max_recourse::Real = parse(Float64, get(ENV, "DR_BAT_MAX_RECOURSE", "1e-6")), + checkpoint::AbstractString = get(ENV, "DR_BAT_CHECKPOINT", + joinpath(@__DIR__, "battery_policy.jld2")), + verbose::Bool = true) + + case = read_battery_case(case_dir) + backend, to_device, solver_kwargs = configure_device(device) + + prob = build_battery_exa(case, Int(num_stages); backend = backend) + + Random.seed!(seed) + rng = StableRNG(seed) + policy = to_device(battery_reachable_policy(case, collect(Int, encoder_layers); + n_observation = prob.nBus, + n_context = N_CONTEXT, + head_layers = collect(Int, head_layers))) + assert_device(policy, device) + + opt_state = Optimisers.setup(Optimisers.Adam(Float64(lr)), policy) + e0 = initial_energy(case) + like = _policy_array(policy) + e0_dev = _to_like(like, e0) + + total_steps = epochs * batches + protocol_stages = Int(case.manifest["protocol"]["num_stages"]) + protocol_scenarios = Int(case.manifest["protocol"]["num_scenarios"]) + protocol_stages >= num_stages || + error("the frozen protocol has $protocol_stages stages but training asks for $num_stages") + + history = NamedTuple[] + best = (cost = Inf, step = 0) + updates = 0 + t_start = time() + + for step in 1:total_steps + Optimisers.adjust!(opt_state, cosine_lr(step, total_steps, lr, lr_final)) + grads = nothing + losses = Float64[] + for _ in 1:trajectories + atoms = sample_atoms(rng, case, Int(num_stages)) + features = rollout_features(case, prob.net, atoms; like = like) + targets = rollout_targets(policy, features, e0_dev) + result, sol, λ = strict_solve!(prob, case, atoms, targets; + solver_kwargs = solver_kwargs) + if !solve_succeeded(result) + @warn "strict solve failed; trajectory skipped" status=result.status step=step + continue + end + push!(losses, sum(stage_costs(prob, sol).total)) + _, g = actor_gradient(policy, features, _to_like(like, λ), e0_dev) + grads = grads === nothing ? g : _add_grads(grads, g) + end + isempty(losses) && continue + grads = _scale_grads(grads, 1 / length(losses)) + opt_state, policy = Optimisers.update!(opt_state, policy, grads) + updates += 1 + push!(history, (step = step, loss = mean(losses), + lr = cosine_lr(step, total_steps, lr, lr_final))) + verbose && @printf("step %4d loss %14.4f lr %.3e\n", step, mean(losses), + cosine_lr(step, total_steps, lr, lr_final)) + + if eval_every > 0 && (step % eval_every == 0 || step == total_steps) + ev = evaluate_panel(policy, prob, case, collect(Int, eval_columns); + protocol_stages = protocol_stages, + protocol_scenarios = protocol_scenarios, + max_recourse = max_recourse, solver_kwargs = solver_kwargs) + verbose && @printf(" panel: mean %14.4f worst recourse %.3e complete %s\n", + ev.mean_cost, ev.worst_recourse, ev.complete) + if ev.complete && ev.mean_cost < best.cost + best = (cost = ev.mean_cost, step = step) + save_checkpoint(checkpoint, policy, Dict( + "case" => case.name, + "network_sha256" => case.manifest["artifacts"]["network.json"], + "num_stages" => Int(num_stages), + "panel_columns" => collect(Int, eval_columns), + "panel_mean_cost" => ev.mean_cost, + "step" => step, + "encoder_layers" => collect(Int, encoder_layers), + "head_layers" => collect(Int, head_layers), + "n_observation" => prob.nBus, + "n_context" => N_CONTEXT, + )) + end + end + end + + return (policy = policy, problem = prob, case = case, + history = history, best = best, updates = updates, + elapsed = time() - t_start, checkpoint = checkpoint) +end + +# ───────────────────────────────────────────────────────────────────────────── +# Device handling +# ───────────────────────────────────────────────────────────────────────────── + +""" + configure_device(device) -> (backend, to_device, solver_kwargs) + +Resolve `"cpu"` or `"gpu"` into an ExaModels backend, a policy mover, and the +MadNLP options that match. + +# Notes +The GPU path is loaded LAZILY, so the CPU path — which every correctness gate and +every CI run uses — never depends on a working CUDA installation. + +Three traps this function exists to avoid. `MadNLPGPU.CUDSSSolver` is `nothing` +unless CUDSS.jl has been loaded, and passing `nothing` as a linear solver fails +far from its cause. `Flux.gpu` is a silent no-op when cuDNN is absent, so a +"GPU" run can quietly execute the policy on the CPU; `cuDNN` is therefore +imported here and [`assert_device`](@ref) checks the outcome rather than trusting +it. And everything the `@eval`ed imports bring into scope is NEWER than this +function's own compiled world, so each of them is reached through +`Base.invokelatest`; calling them directly raises an "UndefVarError … the +binding may be too new". +""" +function configure_device(device::AbstractString) + if lowercase(device) == "cpu" + return nothing, identity, NamedTuple() + end + lowercase(device) == "gpu" || throw(ArgumentError("device must be \"cpu\" or \"gpu\"")) + @eval Main using CUDA, CUDSS, MadNLPGPU, cuDNN, KernelAbstractions + cuda = Base.invokelatest(getglobal, Main, :CUDA) + Base.invokelatest(cuda.functional) || + error("DR_BAT_DEVICE=gpu but CUDA is not functional") + backend = Base.invokelatest(cuda.CUDABackend) + madnlpgpu = Base.invokelatest(getglobal, Main, :MadNLPGPU) + linear_solver = Base.invokelatest(getglobal, madnlpgpu, :CUDSSSolver) + linear_solver === nothing && error("MadNLPGPU.CUDSSSolver is nothing; CUDSS.jl did not load") + return backend, x -> Base.invokelatest(Flux.gpu, x), (linear_solver = linear_solver,) +end + +""" + assert_device(policy, device) + +Fail loudly unless every trainable array and the recurrent state actually live +on the intended device. + +# Notes +A device move that silently did nothing is indistinguishable from a successful +one at the call site, and produces a run that reports GPU timings while +executing on the host. Checking the arrays themselves is the only assertion that +cannot be fooled. +""" +function assert_device(policy::BatteryReachablePolicy, device::AbstractString) + want_gpu = lowercase(device) == "gpu" + arrays = Any[] + Flux.fmap(x -> (x isa AbstractArray && push!(arrays, x); x), policy) + isempty(arrays) && error("assert_device found no arrays in the policy") + for a in arrays + on_gpu = !(a isa Array) + on_gpu == want_gpu || error( + "policy array of type $(typeof(a)) is $(on_gpu ? "on the GPU" : "on the CPU") but device=$device") + end + return nothing +end + +# ───────────────────────────────────────────────────────────────────────────── +# Small helpers +# ───────────────────────────────────────────────────────────────────────────── + +""" + _policy_array(policy) -> AbstractArray + +The first trainable array of `policy`, used as the reference for element type +and device when materializing rollout inputs. + +# Notes +Deriving the working array type from the policy itself — rather than from a +flag — means a policy that failed to move to the GPU produces CPU inputs and a +consistent (if slow) run, instead of a mixed-device `vcat` that fails deep +inside a kernel launch. +""" +function _policy_array(policy::BatteryReachablePolicy) + found = Ref{Any}(nothing) + Flux.fmap(x -> (x isa AbstractArray && found[] === nothing && (found[] = x); x), policy) + found[] === nothing && error("policy carries no arrays") + return found[] +end + +"Materialize `v` with the element type and device of `like`." +function _to_like(like::AbstractArray, v::AbstractVector) + out = similar(like, length(v)) + copyto!(out, eltype(like).(vec(Array(v)))) + return out +end + +"Parse a comma-separated integer list from the environment, with a default." +function _env_ints(key::AbstractString, default::AbstractVector{Int}) + raw = get(ENV, key, "") + isempty(strip(raw)) && return default + return [parse(Int, strip(x)) for x in split(raw, ",") if !isempty(strip(x))] +end + +"Recursively add two Zygote gradient trees of identical structure." +_add_grads(a::AbstractArray, b::AbstractArray) = a .+ b +_add_grads(a::Nothing, b) = b +_add_grads(a, b::Nothing) = a +_add_grads(::Nothing, ::Nothing) = nothing +_add_grads(a::NamedTuple{K}, b::NamedTuple{K}) where {K} = + NamedTuple{K}(map(_add_grads, values(a), values(b))) +_add_grads(a::Tuple, b::Tuple) = map(_add_grads, a, b) +_add_grads(a::Number, b::Number) = a + b + +"Recursively scale a Zygote gradient tree." +_scale_grads(a::AbstractArray, s) = a .* s +_scale_grads(::Nothing, s) = nothing +_scale_grads(a::NamedTuple{K}, s) where {K} = + NamedTuple{K}(map(x -> _scale_grads(x, s), values(a))) +_scale_grads(a::Tuple, s) = map(x -> _scale_grads(x, s), a) +_scale_grads(a::Number, s) = a * s + +if abspath(PROGRAM_FILE) == @__FILE__ + out = train_strict() + @printf("\n%d updates in %.1f s; best complete panel %.4f at step %d\n", + out.updates, out.elapsed, out.best.cost, out.best.step) + @printf("checkpoint: %s\n", out.checkpoint) +end diff --git a/examples/HydroPowerModels/Project.toml b/examples/HydroPowerModels/Project.toml index 30e1a40..fa24e27 100644 --- a/examples/HydroPowerModels/Project.toml +++ b/examples/HydroPowerModels/Project.toml @@ -12,10 +12,15 @@ JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c" MadNLP = "2621e9c9-9eb4-46b1-8089-e8c72242dfb6" MadNLPGPU = "d72a61cc-809d-412f-99be-fd81f4b8a598" +SHA = "ea8e919c-243c-51af-8825-aaa63cd721ce" +StableRNGs = "860ef19b-820b-49d6-a774-d7a799459cd3" Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" Wandb = "ad70616a-06c9-5745-b1f1-6a5f42545108" Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" cuDNN = "02a925ec-e4fe-4b08-9a7e-0d78e3d38ccd" -[sources] -DecisionRulesExa = {path = "../.."} +[extras] +CUDA_Runtime_jll = "76a88914-d11a-5bdc-97e0-2f5a05c973a2" + +[sources.DecisionRulesExa] +path = "../.." diff --git a/examples/HydroPowerModels/README.md b/examples/HydroPowerModels/README.md index 65f91a6..84e4db9 100644 --- a/examples/HydroPowerModels/README.md +++ b/examples/HydroPowerModels/README.md @@ -1,111 +1,117 @@ -# HydroPowerModels Example +# Bolivia hydro — ExaModels engine -Multi-stage hydrothermal scheduling using DecisionRulesExa.jl with DC or AC OPF formulations. +The GPU half of the long-term hydrothermal planning case study: this directory +trains and evaluates the policy. The case, the SDDP baseline and the figures live +in the companion package, `DecisionRules.jl/examples/HydroPowerModels`. -## Problem description +**The science is in the documentation** of that package, under *Case studies → +Long-term hydrothermal planning*. This file is the operating manual. -A hydro-dominated power system (Bolivia test case) is operated over a planning horizon of up to 96 stages. At each stage, the operator must decide generator dispatch, reservoir outflows, and spillage subject to: +The two packages share the case bytes and two source files **byte for byte**: +`bolivia/{PowerModels.json, hydro.json, inflows.csv, *.mof.json, +case_manifest.json}`, `generate_canonical_case_artifacts.jl` and +`hydro_solution_schema.jl`. The case files are mirrored by the other package's +`export_subproblem_mof.jl --exa-root=…`; the source files are copies whose +identity is the point — both engines assert the same case contract and write +their solutions in the same format, without either depending on the other. -- **Power flow constraints** (DC linearization or full AC polar OPF) -- **Reservoir dynamics** (water balance with stochastic inflows) -- **Generator and transmission limits** +## Layout -The TS-DDR policy (an LSTM network) predicts target reservoir levels at each stage. The deterministic-equivalent NLP projects these targets onto the feasible set via slack-penalized target constraints. Training uses envelope-theorem gradients: dual multipliers on the target constraints give the policy gradient without differentiating through the solver. - -## Formulations - -Set `FORMULATION` in `train_hydro_exa.jl`: - -| Formulation | `FORMULATION` | Variables per stage | Description | -|---|---|---|---| -| DC OPF | `:dc` | ~500 | Linear power flow, fast solves | -| AC Polar OPF | `:ac_polar` | ~2000 | Full nonlinear AC power flow | - -## Data - -The `bolivia/` directory contains: - -- `PowerModels.json` — power system topology (39 buses, 55 branches, 19 generators) -- `hydro.json` — hydro unit parameters (7 reservoirs) -- `inflows.csv` — historical inflow scenarios (144 stages x 200 scenarios x 7 reservoirs) -- `_demand.csv` — per-stage bus demand scaling - -Pre-solved deterministic-equivalent references (MOF format) are provided for validation: -- `DCPPowerModel.mof.json` -- `ACPPowerModel.mof.json` - -## Files - -| File | Description | +| file | role | |---|---| -| `train_hydro_exa.jl` | Main training script with penalty scheduling, parallel GPU solves, and W&B logging | -| `train_hydro_exa_critic.jl` | Critic/control-variate variant of the main training script; uses normalized hydro features, a replay buffer, and cheap critic rollouts | -| `hydro_power_data.jl` | Data parsing (PowerModels JSON, hydro JSON, inflows CSV) | -| `hydro_power_exa.jl` | ExaModels problem builder for DC and AC OPF formulations | -| `eval_exa_de.jl` | Validation script comparing ExaModels results against JuMP reference | -| `Project.toml` | Example-specific dependencies (W&B, JLD2, CUDA, etc.) | +| `hydro_power_data.jl` | parses `PowerModels.json` / `hydro.json` / `inflows.csv` into the flat arrays the ExaModels builder consumes | +| `hydro_power_exa.jl` | builds the `ExaModel`: AC-polar or DC, strict or penalized targets, with `hydro_solution` to unpack a solved point into named blocks | +| `hydro_reachable_policy.jl` | the feasibility-guaranteeing policy (LSTM encoder over inflow, state-conditioned head, targets mapped into the one-stage reachable interval) | +| `hydro_solution_schema.jl` | the long format in which a full physical solution is written; byte-identical to the JuMP engine's copy | +| `hydro_training_utils.jl` | small shared helpers for the training scripts | +| `train_hydro_exa_strict.jl` | ONE training stage, fully parameterized by environment variables | +| `run_tsddr_lineage.jl` | the lineage driver: runs a declared multi-stage schedule end to end, chaining only selected checkpoints | +| `lineage_from_scratch.json` | the published from-scratch training schedule, as data: one entry per phase | +| `eval_paired_exa.jl` | paired evaluation of a checkpoint, with per-stage physical recording and an optional full-solution dump | +| `generate_canonical_case_artifacts.jl` | the frozen-case contract and its verifier | -## Running +## Commands -### GPU training (recommended) +Run from this directory with `--project=.`. -```julia -# From this directory: -julia --project -t auto train_hydro_exa.jl -``` +**1. Verify the case.** -Set `USE_GPU = true` in `train_hydro_exa.jl` (default). Requires a CUDA-capable GPU. +```bash +julia --project=. generate_canonical_case_artifacts.jl --verify +``` -### GPU training with critic control variate +**2. A short GPU smoke run** — a few updates on a short horizon, to confirm the +GPU stack (MadNLPGPU + CUDSS + cuDNN) is working before committing hours: -```julia -# From this directory: -julia --project -t auto train_hydro_exa_critic.jl +```bash +DR_NUM_STAGES=8 DR_NUM_ROLLOUT_STAGES=8 \ +DR_NUM_EPOCHS=1 DR_NUM_BATCHES=3 DR_NUM_TRAIN_PER_BATCH=2 \ +DR_NUM_EVAL_SCENARIOS=2 DR_EVAL_PROTOCOL_IDS=2,39 DR_EVAL_EVERY=3 \ +DR_ENABLE_WANDB=false \ + julia --project=. -t auto train_hydro_exa_strict.jl ``` -The critic script keeps the dual-multiplier actor update but adds a damped -control variate (`critic_cv_weight = 0.5`) trained on the stage-wise rollout -objective without target penalty. Its default critic rollout uses -`policy_state = :target`; set `CRITIC_POLICY_STATE = :realized` for closed-loop -critic labels. Deterministic-equivalent critic fitting remains available as an -ablation through `DeterministicEquivalentCriticTarget()`. +**3. The full from-scratch training recipe.** This is the published schedule, +declared in `lineage_from_scratch.json` and executed stage by stage: -### CPU training +```bash +julia --project=. run_tsddr_lineage.jl # full lineage +julia --project=. run_tsddr_lineage.jl --dry-run # print the plan only +julia --project=. run_tsddr_lineage.jl --stages=phase3 # resume one phase +``` -Set `USE_GPU = false` in `train_hydro_exa.jl`, then run the same command. +Each stage runs as its own process, so a stage boundary is a real restart: the +optimizer state, the cosine learning-rate phase and the warm-up counter all +begin again. The driver chains only checkpoints that a COMPLETE, non-shedding +panel evaluation selected, hashes every parent before use, refuses `_latest` +snapshots outright, and stops the lineage — rather than falling back — if a +stage produces nothing selectable. Re-running resumes: a stage whose record +exists and whose checkpoint still hashes correctly is skipped. -### Configuration +Records land in `bolivia/ACPPowerModel/lineage/`: one JSON per stage with the +resolved environment, ancestry, checkpoint hashes, update count and both the +process wall time and the trainer's own training-loop seconds, plus a +lineage-level ledger. -Key parameters in `train_hydro_exa.jl`: +Neither W&B nor a workload manager is required. `DR_ENABLE_WANDB=false` turns +logging off; nothing in the driver reads a scheduler variable. -| Parameter | Default | Description | -|---|---|---| -| `FORMULATION` | `:ac_polar` | OPF formulation (`:dc` or `:ac_polar`) | -| `NUM_STAGES` | 96 | Planning horizon | -| `NUM_EPOCHS` | 20 | Training epochs | -| `NUM_BATCHES` | 100 | Gradient steps per epoch | -| `NUM_WORKERS` | 4 | Parallel GPU solver instances | -| `LAYERS` | `[128, 128]` | LSTM hidden layer sizes | -| `LR` | 1e-3 | Learning rate | -| `DEFICIT_COST` | 1e5 | Load-shedding penalty ($/pu) | +**4. Paired evaluation of a checkpoint.** -### Training features +```bash +DR_EVAL_CKPT=/path/to/checkpoint.jld2 DR_EVAL_LABEL=my_policy \ + julia --project=. -t auto eval_paired_exa.jl # the 10-column panel -- **Penalty scheduling**: target penalty multiplier ramps through phases (0.1 -> 1.0 -> 10.0 -> 30.0) over training -- **Sample scheduling**: `num_train_per_batch` increases from `NUM_WORKERS` to `8 * NUM_WORKERS` -- **Evaluation scheduling**: rollout evaluation starts with 4 scenarios and ramps to 32 at halfway -- **Parallel solves**: independent NLP copies solved concurrently via `Threads.@spawn` worker pool -- **Parallel rollout**: evaluation scenarios distributed across CPU stage-problem copies -- **Critic variant**: optional scalar critic with value and gradient matching, - replay-buffer training, and cheap critic actor samples -- **W&B logging**: training loss, rollout objectives, violation share, penalty multiplier +DR_EVAL_CKPT=… DR_EVAL_LABEL=shard_1_50 \ +DR_EVAL_COL_FIRST=1 DR_EVAL_COL_LAST=50 \ + julia --project=. -t auto eval_paired_exa.jl # one shard of the 500 +``` -## Validation +Adding `DR_SOLUTION_DUMP=1` additionally writes the full primal solution of every +stage and the decision trace that reproduces it, in the shared long format of +`hydro_solution_schema.jl` — the per-bus, per-branch physics the stagewise +figures are built from. (Nodal prices are duals and come from the JuMP engine's +evaluators, which have them directly.) -Compare the ExaModels formulation against a JuMP/MadNLP reference: +## Configuration surface of one training stage -```julia -julia --project -t auto eval_exa_de.jl -``` +`train_hydro_exa_strict.jl` is driven entirely by environment variables; the +lineage driver simply sets them. The ones that define a stage: -This loads a pre-solved JuMP reference and solves the same problem in ExaModels, printing a side-by-side comparison of objectives and reservoir trajectories. +| variable | meaning | +|---|---| +| `DR_NUM_TRAIN_PER_BATCH` | `nt`, trajectories sampled per gradient step | +| `DR_LR`, `DR_LR_FINAL`, `DR_LR_WARMUP` | cosine learning-rate schedule and its warm-up | +| `DR_NUM_EPOCHS` × `DR_NUM_BATCHES` | the update budget | +| `DR_MAX_TRAIN_SECONDS` | wall budget for the training loop | +| `DR_EVAL_EVERY`, `DR_EVAL_PROTOCOL_IDS`, `DR_NUM_EVAL_SCENARIOS` | the fixed evaluation panel and its cadence | +| `DR_SAVE_METRIC=rollout` | select checkpoints on the panel, not on the training loss | +| `DR_MAX_DEFICIT_PU` | reject an evaluation that shed load | +| `DR_ROLLOUT_PARALLEL`, `DR_ROLLOUT_RETRY_FAILED` | pooled vs sequential evaluation, and whether a failed scenario is retried sequentially | +| `DR_PRETRAINED_MODEL`, `DR_SEED_BEST`, `DR_PARENT_REPRO_TOL` | the parent checkpoint, its recorded value, and how exactly it must reproduce | +| `DR_STAGE_SUMMARY` | where to write the machine-readable end-of-stage record | + +`DR_STOP_AFTER_STALE_EVALS` exists but defaults off, and should stay off unless a +stage is expected to improve monotonically: raising the learning rate at a +restart reliably degrades the policy before it recovers, and a small stale count +terminates the stage inside that dip. diff --git a/examples/HydroPowerModels/bolivia/ACPPowerModel.mof.json b/examples/HydroPowerModels/bolivia/ACPPowerModel.mof.json index 5e63547..a38c526 100644 --- a/examples/HydroPowerModels/bolivia/ACPPowerModel.mof.json +++ b/examples/HydroPowerModels/bolivia/ACPPowerModel.mof.json @@ -1,39045 +1 @@ -{ - "name": "MathOptFormat Model", - "version": { - "major": 1, - "minor": 7 - }, - "variables": [ - { - "name": "reservoir[1]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[2]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[3]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[4]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[5]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[6]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[7]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[8]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[9]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[10]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[11]_in", - "primal_start": 0.0 - }, - { - "name": "inflow[1]", - "primal_start": 0.0 - }, - { - "name": "inflow[2]", - "primal_start": 0.0 - }, - { - "name": "inflow[3]", - "primal_start": 0.0 - }, - { - "name": "inflow[4]", - "primal_start": 0.0 - }, - { - "name": "inflow[5]", - "primal_start": 0.0 - }, - { - "name": "inflow[6]", - "primal_start": 0.0 - }, - { - "name": "inflow[7]", - "primal_start": 0.0 - }, - { - "name": "inflow[8]", - "primal_start": 0.0 - }, - { - "name": "inflow[9]", - "primal_start": 0.0 - }, - { - "name": "inflow[10]", - "primal_start": 0.0 - }, - { - "name": "inflow[11]", - "primal_start": 0.0 - }, - { - "name": "0_vm[5]", - "primal_start": 1.0 - }, - { - "name": "0_vm[16]", - "primal_start": 1.0 - }, - { - "name": "0_vm[20]", - "primal_start": 1.0 - }, - { - "name": "0_vm[12]", - "primal_start": 1.0 - }, - { - "name": "0_vm[24]", - "primal_start": 1.0 - }, - { - "name": "0_vm[28]", - "primal_start": 1.0 - }, - { - "name": "0_vm[8]", - "primal_start": 1.0 - }, - { - "name": "0_vm[17]", - "primal_start": 1.0 - }, - { - "name": "0_vm[1]", - "primal_start": 1.0 - }, - { - "name": "0_vm[23]", - "primal_start": 1.0 - }, - { - "name": "0_vm[22]", - "primal_start": 1.0 - }, - { - "name": "0_vm[19]", - "primal_start": 1.0 - }, - { - "name": "0_vm[6]", - "primal_start": 1.0 - }, - { - "name": "0_vm[11]", - "primal_start": 1.0 - }, - { - "name": "0_vm[9]", - "primal_start": 1.0 - }, - { - "name": "0_vm[14]", - "primal_start": 1.0 - }, - { - "name": "0_vm[3]", - "primal_start": 1.0 - }, - { - "name": "0_vm[7]", - "primal_start": 1.0 - }, - { - "name": "0_vm[25]", - "primal_start": 1.0 - }, - { - "name": "0_vm[4]", - "primal_start": 1.0 - }, - { - "name": "0_vm[13]", - "primal_start": 1.0 - }, - { - "name": "0_vm[15]", - "primal_start": 1.0 - }, - { - "name": "0_vm[2]", - "primal_start": 1.0 - }, - { - "name": "0_vm[27]", - "primal_start": 1.0 - }, - { - "name": "0_vm[21]", - "primal_start": 1.0 - }, - { - "name": "0_vm[26]", - "primal_start": 1.0 - }, - { - "name": "0_vm[10]", - "primal_start": 1.0 - }, - { - "name": "0_vm[18]", - "primal_start": 1.0 - }, - { - "name": "0_pg[5]", - "primal_start": 0.0 - }, - { - "name": "0_pg[16]", - "primal_start": 0.0 - }, - { - "name": "0_pg[20]", - "primal_start": 0.0 - }, - { - "name": "0_pg[12]", - "primal_start": 0.0 - }, - { - "name": "0_pg[24]", - "primal_start": 0.0 - }, - { - "name": "0_pg[28]", - "primal_start": 0.0 - }, - { - "name": "0_pg[8]", - "primal_start": 0.0 - }, - { - "name": "0_pg[17]", - "primal_start": 0.0 - }, - { - "name": "0_pg[30]", - "primal_start": 0.0 - }, - { - "name": "0_pg[1]", - "primal_start": 0.0 - }, - { - "name": "0_pg[23]", - "primal_start": 0.0 - }, - { - "name": "0_pg[32]", - "primal_start": 0.0 - }, - { - "name": "0_pg[22]", - "primal_start": 0.0 - }, - { - "name": "0_pg[6]", - "primal_start": 0.0 - }, - { - "name": "0_pg[19]", - "primal_start": 0.0 - }, - { - "name": "0_pg[11]", - "primal_start": 0.0 - }, - { - "name": "0_pg[31]", - "primal_start": 0.0 - }, - { - "name": "0_pg[9]", - "primal_start": 0.0 - }, - { - "name": "0_pg[14]", - "primal_start": 0.0 - }, - { - "name": "0_pg[3]", - "primal_start": 0.0 - }, - { - "name": "0_pg[29]", - "primal_start": 0.0 - }, - { - "name": "0_pg[33]", - "primal_start": 0.0 - }, - { - "name": "0_pg[25]", - "primal_start": 0.0 - }, - { - "name": "0_pg[7]", - "primal_start": 0.0 - }, - { - "name": "0_pg[34]", - "primal_start": 0.0 - }, - { - "name": "0_pg[4]", - "primal_start": 0.0 - }, - { - "name": "0_pg[13]", - "primal_start": 0.0 - }, - { - "name": "0_pg[15]", - "primal_start": 0.0 - }, - { - "name": "0_pg[2]", - "primal_start": 0.0 - }, - { - "name": "0_pg[27]", - "primal_start": 0.0 - }, - { - "name": "0_pg[21]", - "primal_start": 0.0 - }, - { - "name": "0_pg[26]", - "primal_start": 0.0 - }, - { - "name": "0_pg[10]", - "primal_start": 0.0 - }, - { - "name": "0_pg[18]", - "primal_start": 0.0 - }, - { - "name": "0_qg[5]", - "primal_start": 0.0 - }, - { - "name": "0_qg[16]", - "primal_start": 0.0 - }, - { - "name": "0_qg[20]", - "primal_start": 0.0 - }, - { - "name": "0_qg[12]", - "primal_start": 0.0 - }, - { - "name": "0_qg[24]", - "primal_start": 0.0 - }, - { - "name": "0_qg[28]", - "primal_start": 0.0 - }, - { - "name": "0_qg[8]", - "primal_start": 0.0 - }, - { - "name": "0_qg[17]", - "primal_start": 0.0 - }, - { - "name": "0_qg[30]", - "primal_start": 0.0 - }, - { - "name": "0_qg[1]", - "primal_start": 0.0 - }, - { - "name": "0_qg[23]", - "primal_start": 0.0 - }, - { - "name": "0_qg[32]", - "primal_start": 0.0 - }, - { - "name": "0_qg[22]", - "primal_start": 0.0 - }, - { - "name": "0_qg[6]", - "primal_start": 0.0 - }, - { - "name": "0_qg[19]", - "primal_start": 0.0 - }, - { - "name": "0_qg[11]", - "primal_start": 0.0 - }, - { - "name": "0_qg[31]", - "primal_start": 0.0 - }, - { - "name": "0_qg[9]", - "primal_start": 0.0 - }, - { - "name": "0_qg[14]", - "primal_start": 0.0 - }, - { - "name": "0_qg[3]", - "primal_start": 0.0 - }, - { - "name": "0_qg[29]", - "primal_start": 0.0 - }, - { - "name": "0_qg[33]", - "primal_start": 0.0 - }, - { - "name": "0_qg[25]", - "primal_start": 0.0 - }, - { - "name": "0_qg[7]", - "primal_start": 0.0 - }, - { - "name": "0_qg[34]", - "primal_start": 0.0 - }, - { - "name": "0_qg[4]", - "primal_start": 0.0 - }, - { - "name": "0_qg[13]", - "primal_start": 0.0 - }, - { - "name": "0_qg[15]", - "primal_start": 0.0 - }, - { - "name": "0_qg[2]", - "primal_start": 0.0 - }, - { - "name": "0_qg[27]", - "primal_start": 0.0 - }, - { - "name": "0_qg[21]", - "primal_start": 0.0 - }, - { - "name": "0_qg[26]", - "primal_start": 0.0 - }, - { - "name": "0_qg[10]", - "primal_start": 0.0 - }, - { - "name": "0_qg[18]", - "primal_start": 0.0 - }, - { - "name": "0_p[(5, 5, 6)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(16, 13, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(20, 16, 17)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(12, 9, 12)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(24, 21, 22)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(28, 25, 26)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(8, 7, 8)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(17, 14, 15)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(30, 19, 28)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(1, 2, 1)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(23, 20, 21)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(22, 16, 19)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(19, 14, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(6, 5, 11)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(11, 9, 10)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(31, 19, 28)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(9, 7, 10)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(14, 11, 18)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(3, 3, 4)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(29, 17, 27)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(7, 6, 7)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(25, 22, 23)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(4, 4, 5)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(13, 9, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(15, 12, 13)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(2, 2, 3)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(27, 24, 25)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(21, 18, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(26, 23, 24)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(10, 8, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(18, 14, 20)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(5, 6, 5)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(16, 14, 13)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(20, 17, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(12, 12, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(24, 22, 21)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(28, 26, 25)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(8, 8, 7)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(17, 15, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(30, 28, 19)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(1, 1, 2)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(23, 21, 20)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(22, 19, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(19, 16, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(6, 11, 5)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(11, 10, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(31, 28, 19)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(9, 10, 7)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(14, 18, 11)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(3, 4, 3)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(29, 27, 17)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(7, 7, 6)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(25, 23, 22)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(4, 5, 4)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(13, 16, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(15, 13, 12)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(2, 3, 2)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(27, 25, 24)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(21, 16, 18)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(26, 24, 23)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(10, 9, 8)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(18, 20, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(5, 5, 6)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(16, 13, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(20, 16, 17)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(12, 9, 12)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(24, 21, 22)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(28, 25, 26)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(8, 7, 8)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(17, 14, 15)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(30, 19, 28)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(1, 2, 1)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(23, 20, 21)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(22, 16, 19)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(19, 14, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(6, 5, 11)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(11, 9, 10)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(31, 19, 28)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(9, 7, 10)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(14, 11, 18)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(3, 3, 4)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(29, 17, 27)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(7, 6, 7)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(25, 22, 23)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(4, 4, 5)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(13, 9, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(15, 12, 13)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(2, 2, 3)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(27, 24, 25)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(21, 18, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(26, 23, 24)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(10, 8, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(18, 14, 20)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(5, 6, 5)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(16, 14, 13)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(20, 17, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(12, 12, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(24, 22, 21)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(28, 26, 25)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(8, 8, 7)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(17, 15, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(30, 28, 19)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(1, 1, 2)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(23, 21, 20)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(22, 19, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(19, 16, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(6, 11, 5)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(11, 10, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(31, 28, 19)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(9, 10, 7)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(14, 18, 11)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(3, 4, 3)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(29, 27, 17)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(7, 7, 6)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(25, 23, 22)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(4, 5, 4)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(13, 16, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(15, 13, 12)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(2, 3, 2)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(27, 25, 24)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(21, 16, 18)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(26, 24, 23)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(10, 9, 8)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(18, 20, 14)]", - "primal_start": 0.0 - }, - { - "name": "reservoir[1]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[2]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[3]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[4]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[5]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[6]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[7]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[8]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[9]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[10]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[11]_out", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[1]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[2]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[3]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[4]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[5]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[6]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[7]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[8]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[9]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[10]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[11]", - "primal_start": 0.0 - }, - { - "name": "outflow[1]", - "primal_start": 0.0 - }, - { - "name": "outflow[2]", - "primal_start": 0.0 - }, - { - "name": "outflow[3]", - "primal_start": 0.0 - }, - { - "name": "outflow[4]", - "primal_start": 0.0 - }, - { - "name": "outflow[5]", - "primal_start": 0.0 - }, - { - "name": "outflow[6]", - "primal_start": 0.0 - }, - { - "name": "outflow[7]", - "primal_start": 0.0 - }, - { - "name": "outflow[8]", - "primal_start": 0.0 - }, - { - "name": "outflow[9]", - "primal_start": 0.0 - }, - { - "name": "outflow[10]", - "primal_start": 0.0 - }, - { - "name": "outflow[11]", - "primal_start": 0.0 - }, - { - "name": "spill[1]", - "primal_start": 0.0 - }, - { - "name": "spill[2]", - "primal_start": 0.0 - }, - { - "name": "spill[3]", - "primal_start": 0.0 - }, - { - "name": "spill[4]", - "primal_start": 0.0 - }, - { - "name": "spill[5]", - "primal_start": 0.0 - }, - { - "name": "spill[6]", - "primal_start": 0.0 - }, - { - "name": "spill[7]", - "primal_start": 0.0 - }, - { - "name": "spill[8]", - "primal_start": 0.0 - }, - { - "name": "spill[9]", - "primal_start": 0.0 - }, - { - "name": "spill[10]", - "primal_start": 0.0 - }, - { - "name": "spill[11]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[1]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[2]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[3]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[4]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[5]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[6]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[7]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[8]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[9]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[10]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[11]", - "primal_start": 0.0 - }, - { - "name": "deficit[1]", - "primal_start": 0.0 - }, - { - "name": "deficit[2]", - "primal_start": 0.0 - }, - { - "name": "deficit[3]", - "primal_start": 0.0 - }, - { - "name": "deficit[4]", - "primal_start": 0.0 - }, - { - "name": "deficit[5]", - "primal_start": 0.0 - }, - { - "name": "deficit[6]", - "primal_start": 0.0 - }, - { - "name": "deficit[7]", - "primal_start": 0.0 - }, - { - "name": "deficit[8]", - "primal_start": 0.0 - }, - { - "name": "deficit[9]", - "primal_start": 0.0 - }, - { - "name": "deficit[10]", - "primal_start": 0.0 - }, - { - "name": "deficit[11]", - "primal_start": 0.0 - }, - { - "name": "deficit[12]", - "primal_start": 0.0 - }, - { - "name": "deficit[13]", - "primal_start": 0.0 - }, - { - "name": "deficit[14]", - "primal_start": 0.0 - }, - { - "name": "deficit[15]", - "primal_start": 0.0 - }, - { - "name": "deficit[16]", - "primal_start": 0.0 - }, - { - "name": "deficit[17]", - "primal_start": 0.0 - }, - { - "name": "deficit[18]", - "primal_start": 0.0 - }, - { - "name": "deficit[19]", - "primal_start": 0.0 - }, - { - "name": "deficit[20]", - "primal_start": 0.0 - }, - { - "name": "deficit[21]", - "primal_start": 0.0 - }, - { - "name": "deficit[22]", - "primal_start": 0.0 - }, - { - "name": "deficit[23]", - "primal_start": 0.0 - }, - { - "name": "deficit[24]", - "primal_start": 0.0 - }, - { - "name": "deficit[25]", - "primal_start": 0.0 - }, - { - "name": "deficit[26]", - "primal_start": 0.0 - }, - { - "name": "deficit[27]", - "primal_start": 0.0 - }, - { - "name": "deficit[28]", - "primal_start": 0.0 - }, - { - "name": "0_va[5]", - "primal_start": 0.0 - }, - { - "name": "0_va[16]", - "primal_start": 0.0 - }, - { - "name": "0_va[20]", - "primal_start": 0.0 - }, - { - "name": "0_va[12]", - "primal_start": 0.0 - }, - { - "name": "0_va[24]", - "primal_start": 0.0 - }, - { - "name": "0_va[28]", - "primal_start": 0.0 - }, - { - "name": "0_va[8]", - "primal_start": 0.0 - }, - { - "name": "0_va[17]", - "primal_start": 0.0 - }, - { - "name": "0_va[1]", - "primal_start": 0.0 - }, - { - "name": "0_va[23]", - "primal_start": 0.0 - }, - { - "name": "0_va[22]", - "primal_start": 0.0 - }, - { - "name": "0_va[19]", - "primal_start": 0.0 - }, - { - "name": "0_va[6]", - "primal_start": 0.0 - }, - { - "name": "0_va[11]", - "primal_start": 0.0 - }, - { - "name": "0_va[9]", - "primal_start": 0.0 - }, - { - "name": "0_va[14]", - "primal_start": 0.0 - }, - { - "name": "0_va[3]", - "primal_start": 0.0 - }, - { - "name": "0_va[7]", - "primal_start": 0.0 - }, - { - "name": "0_va[25]", - "primal_start": 0.0 - }, - { - "name": "0_va[4]", - "primal_start": 0.0 - }, - { - "name": "0_va[13]", - "primal_start": 0.0 - }, - { - "name": "0_va[15]", - "primal_start": 0.0 - }, - { - "name": "0_va[2]", - "primal_start": 0.0 - }, - { - "name": "0_va[27]", - "primal_start": 0.0 - }, - { - "name": "0_va[21]", - "primal_start": 0.0 - }, - { - "name": "0_va[26]", - "primal_start": 0.0 - }, - { - "name": "0_va[10]", - "primal_start": 0.0 - }, - { - "name": "0_va[18]", - "primal_start": 0.0 - } - ], - "objective": { - "sense": "min", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 6000.0, - "variable": "deficit[1]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[2]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[3]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[4]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[5]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[6]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[7]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[8]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[9]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[10]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[11]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[12]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[13]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[14]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[15]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[16]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[17]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[18]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[19]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[20]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[21]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[22]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[23]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[24]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[25]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[26]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[27]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[28]" - }, - { - "coefficient": 2268.0, - "variable": "0_pg[5]" - }, - { - "coefficient": 2059.0, - "variable": "0_pg[16]" - }, - { - "coefficient": 1780.0, - "variable": "0_pg[20]" - }, - { - "coefficient": 1576.0, - "variable": "0_pg[12]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[24]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[28]" - }, - { - "coefficient": 1754.0, - "variable": "0_pg[8]" - }, - { - "coefficient": 2059.0, - "variable": "0_pg[17]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[30]" - }, - { - "coefficient": 1918.0, - "variable": "0_pg[1]" - }, - { - "coefficient": 4244.0, - "variable": "0_pg[23]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[32]" - }, - { - "coefficient": 1517.0, - "variable": "0_pg[22]" - }, - { - "coefficient": 2131.0, - "variable": "0_pg[6]" - }, - { - "coefficient": 1780.0, - "variable": "0_pg[19]" - }, - { - "coefficient": 1576.0, - "variable": "0_pg[11]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[31]" - }, - { - "coefficient": 1576.0, - "variable": "0_pg[9]" - }, - { - "coefficient": 1404.0, - "variable": "0_pg[14]" - }, - { - "coefficient": 2184.0, - "variable": "0_pg[3]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[29]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[33]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[25]" - }, - { - "coefficient": 1822.0, - "variable": "0_pg[7]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[34]" - }, - { - "coefficient": 2179.0, - "variable": "0_pg[4]" - }, - { - "coefficient": 1404.0, - "variable": "0_pg[13]" - }, - { - "coefficient": 2077.0, - "variable": "0_pg[15]" - }, - { - "coefficient": 2120.0, - "variable": "0_pg[2]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[27]" - }, - { - "coefficient": 1598.0, - "variable": "0_pg[21]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[26]" - }, - { - "coefficient": 1576.0, - "variable": "0_pg[10]" - }, - { - "coefficient": 2059.0, - "variable": "0_pg[18]" - } - ], - "constant": 0.0 - } - }, - "constraints": [ - { - "name": "c1", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.4213950047523992, - "0_vm[5]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[5]", - "0_vm[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.4213950047523992, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[5]", - "0_vm[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 12.485777918589607, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(5, 5, 6)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c2", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 12.485777918589607, - "0_vm[5]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[5]", - "0_vm[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 12.485777918589607, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[5]", - "0_vm[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.4213950047523992, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(5, 5, 6)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c3", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.4213950047523992, - "0_vm[6]", - "0_vm[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[6]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.4213950047523992, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[6]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 12.485777918589607, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(5, 6, 5)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c4", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 12.485777918589607, - "0_vm[6]", - "0_vm[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[6]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 12.485777918589607, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[6]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.4213950047523992, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(5, 6, 5)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c5", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.46024690223052, - "0_vm[13]", - "0_vm[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[13]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.46024690223052, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[13]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 6.795713842466891, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(16, 13, 14)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c6", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 6.787563842466891, - "0_vm[13]", - "0_vm[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[13]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 6.795713842466891, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[13]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.46024690223052, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(16, 13, 14)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c7", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.46024690223052, - "0_vm[14]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.46024690223052, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 6.795713842466891, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(16, 14, 13)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c8", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 6.787563842466891, - "0_vm[14]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 6.795713842466891, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.46024690223052, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(16, 14, 13)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c9", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.7456627284627748, - "0_vm[16]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.7456627284627748, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 10.149298248521102, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(20, 16, 17)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c10", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 10.149298248521102, - "0_vm[16]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 10.149298248521102, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.7456627284627748, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(20, 16, 17)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c11", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.7456627284627748, - "0_vm[17]", - "0_vm[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[17]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.7456627284627748, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[17]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 10.149298248521102, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(20, 17, 16)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c12", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 10.149298248521102, - "0_vm[17]", - "0_vm[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[17]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 10.149298248521102, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[17]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.7456627284627748, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(20, 17, 16)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c13", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.3473152225768015, - "0_vm[9]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[12]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.3473152225768015, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[12]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 6.481250938450924, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(12, 9, 12)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c14", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 6.472700938450925, - "0_vm[9]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[12]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 6.481250938450924, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[12]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.3473152225768015, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(12, 9, 12)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c15", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.3473152225768015, - "0_vm[12]", - "0_vm[12]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[12]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.3473152225768015, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[12]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 6.481250938450924, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(12, 12, 9)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c16", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 6.472700938450925, - "0_vm[12]", - "0_vm[12]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[12]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 6.481250938450924, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[12]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.3473152225768015, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(12, 12, 9)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c17", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.13631367642289954, - "0_vm[21]", - "0_vm[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[21]", - "0_vm[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[22]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.13631367642289954, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[21]", - "0_vm[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[22]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 4.2328983731321435, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(24, 21, 22)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c18", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 4.2328983731321435, - "0_vm[21]", - "0_vm[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[21]", - "0_vm[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[22]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 4.2328983731321435, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[21]", - "0_vm[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[22]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.13631367642289954, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(24, 21, 22)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c19", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.13631367642289954, - "0_vm[22]", - "0_vm[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[22]", - "0_vm[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[22]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.13631367642289954, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[22]", - "0_vm[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[22]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 4.2328983731321435, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(24, 22, 21)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c20", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 4.2328983731321435, - "0_vm[22]", - "0_vm[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[22]", - "0_vm[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[22]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 4.2328983731321435, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[22]", - "0_vm[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[22]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.13631367642289954, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(24, 22, 21)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c21", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.0916977112407253, - "0_vm[25]", - "0_vm[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[25]", - "0_vm[26]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[25]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[26]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -1.0916977112407253, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[25]", - "0_vm[26]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[25]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[26]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 2.091029561081878, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(28, 25, 26)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c22", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.088179561081878, - "0_vm[25]", - "0_vm[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[25]", - "0_vm[26]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[25]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[26]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 2.091029561081878, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[25]", - "0_vm[26]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[25]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[26]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -1.0916977112407253, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(28, 25, 26)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c23", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.0916977112407253, - "0_vm[26]", - "0_vm[26]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[26]", - "0_vm[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[25]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[26]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -1.0916977112407253, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[26]", - "0_vm[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[25]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[26]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 2.091029561081878, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(28, 26, 25)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c24", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.088179561081878, - "0_vm[26]", - "0_vm[26]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[26]", - "0_vm[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[25]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[26]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 2.091029561081878, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[26]", - "0_vm[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[25]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[26]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -1.0916977112407253, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(28, 26, 25)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c25", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 15.980730481506358, - "0_vm[7]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[7]", - "0_vm[8]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -15.980730481506358, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[7]", - "0_vm[8]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 45.39453875906154, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(8, 7, 8)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c26", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 45.39333875906154, - "0_vm[7]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[7]", - "0_vm[8]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 45.39453875906154, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[7]", - "0_vm[8]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -15.980730481506358, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(8, 7, 8)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c27", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 15.980730481506358, - "0_vm[8]", - "0_vm[8]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[8]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -15.980730481506358, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[8]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 45.39453875906154, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(8, 8, 7)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c28", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 45.39333875906154, - "0_vm[8]", - "0_vm[8]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[8]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 45.39453875906154, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[8]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -15.980730481506358, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(8, 8, 7)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c29", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.4325735387749903, - "0_vm[14]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[15]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[15]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -1.4325735387749903, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[15]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[15]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 19.8968547052082, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(17, 14, 15)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c30", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 19.8968547052082, - "0_vm[14]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[15]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[15]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 19.8968547052082, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[15]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[15]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -1.4325735387749903, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(17, 14, 15)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c31", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.4325735387749903, - "0_vm[15]", - "0_vm[15]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[15]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[15]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -1.4325735387749903, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[15]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[15]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 19.8968547052082, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(17, 15, 14)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c32", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 19.8968547052082, - "0_vm[15]", - "0_vm[15]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[15]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[15]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 19.8968547052082, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[15]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[15]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -1.4325735387749903, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(17, 15, 14)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c33", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.8777625235737184, - "0_vm[19]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[19]", - "0_vm[28]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.8777625235737184, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[19]", - "0_vm[28]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 9.121944633618186, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(30, 19, 28)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c34", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 9.097144633618186, - "0_vm[19]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[19]", - "0_vm[28]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 9.121944633618186, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[19]", - "0_vm[28]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.8777625235737184, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(30, 19, 28)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c35", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.8777625235737184, - "0_vm[28]", - "0_vm[28]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[28]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.8777625235737184, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[28]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 9.121944633618186, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(30, 28, 19)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c36", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 9.097144633618186, - "0_vm[28]", - "0_vm[28]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[28]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 9.121944633618186, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[28]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.8777625235737184, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(30, 28, 19)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c37", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.28958087993976717, - "0_vm[2]", - "0_vm[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[2]", - "0_vm[1]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[1]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.28958087993976717, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[2]", - "0_vm[1]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[1]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 9.363115118052471, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(1, 2, 1)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c38", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 9.363115118052471, - "0_vm[2]", - "0_vm[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[2]", - "0_vm[1]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[1]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 9.363115118052471, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[2]", - "0_vm[1]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[1]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.28958087993976717, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(1, 2, 1)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c39", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.28958087993976717, - "0_vm[1]", - "0_vm[1]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[1]", - "0_vm[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[1]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.28958087993976717, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[1]", - "0_vm[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[1]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 9.363115118052471, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(1, 1, 2)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c40", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 9.363115118052471, - "0_vm[1]", - "0_vm[1]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[1]", - "0_vm[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[1]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 9.363115118052471, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[1]", - "0_vm[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[1]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.28958087993976717, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(1, 1, 2)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c41", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.128676282013955, - "0_vm[20]", - "0_vm[20]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[20]", - "0_vm[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -1.128676282013955, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[20]", - "0_vm[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 3.33399327650884, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(23, 20, 21)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c42", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 3.3189932765088397, - "0_vm[20]", - "0_vm[20]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[20]", - "0_vm[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 3.33399327650884, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[20]", - "0_vm[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -1.128676282013955, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(23, 20, 21)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c43", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.128676282013955, - "0_vm[21]", - "0_vm[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[21]", - "0_vm[20]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -1.128676282013955, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[21]", - "0_vm[20]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 3.33399327650884, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(23, 21, 20)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c44", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 3.3189932765088397, - "0_vm[21]", - "0_vm[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[21]", - "0_vm[20]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 3.33399327650884, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[21]", - "0_vm[20]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -1.128676282013955, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(23, 21, 20)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c45", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.8287243608560181, - "0_vm[16]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.8287243608560181, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 2.8140484527509644, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(22, 16, 19)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c46", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.7777484527509646, - "0_vm[16]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 2.8140484527509644, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.8287243608560181, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(22, 16, 19)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c47", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.8287243608560181, - "0_vm[19]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[19]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.8287243608560181, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[19]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 2.8140484527509644, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(22, 19, 16)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c48", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.7777484527509646, - "0_vm[19]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[19]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 2.8140484527509644, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[19]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.8287243608560181, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(22, 19, 16)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c49", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.2416585439004273, - "0_vm[14]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -1.2416585439004273, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 3.667991302391842, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(19, 14, 16)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c50", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 3.654341302391842, - "0_vm[14]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 3.667991302391842, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -1.2416585439004273, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(19, 14, 16)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c51", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.2416585439004273, - "0_vm[16]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -1.2416585439004273, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 3.667991302391842, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(19, 16, 14)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c52", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 3.654341302391842, - "0_vm[16]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 3.667991302391842, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -1.2416585439004273, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(19, 16, 14)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c53", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 3.027806843733998, - "0_vm[5]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[5]", - "0_vm[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -3.027806843733998, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[5]", - "0_vm[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 20.88296190751831, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(6, 5, 11)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c54", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 20.83991190751831, - "0_vm[5]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[5]", - "0_vm[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 20.88296190751831, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[5]", - "0_vm[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -3.027806843733998, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(6, 5, 11)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c55", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 3.027806843733998, - "0_vm[11]", - "0_vm[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[11]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -3.027806843733998, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[11]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 20.88296190751831, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(6, 11, 5)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c56", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 20.83991190751831, - "0_vm[11]", - "0_vm[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[11]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 20.88296190751831, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[11]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -3.027806843733998, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(6, 11, 5)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c57", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 17.788682717374634, - "0_vm[9]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -17.788682717374634, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 52.44594387363901, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(11, 9, 10)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c58", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 52.44499387363901, - "0_vm[9]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 52.44594387363901, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -17.788682717374634, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(11, 9, 10)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c59", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 17.788682717374634, - "0_vm[10]", - "0_vm[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[10]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -17.788682717374634, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[10]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 52.44594387363901, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(11, 10, 9)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c60", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 52.44499387363901, - "0_vm[10]", - "0_vm[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[10]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 52.44594387363901, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[10]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -17.788682717374634, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(11, 10, 9)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c61", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.9656776626482336, - "0_vm[19]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[19]", - "0_vm[28]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.9656776626482336, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[19]", - "0_vm[28]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 5.498037005409949, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(31, 19, 28)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c62", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 5.487437005409949, - "0_vm[19]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[19]", - "0_vm[28]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 5.498037005409949, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[19]", - "0_vm[28]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.9656776626482336, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(31, 19, 28)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c63", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.9656776626482336, - "0_vm[28]", - "0_vm[28]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[28]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.9656776626482336, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[28]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 5.498037005409949, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(31, 28, 19)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c64", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 5.487437005409949, - "0_vm[28]", - "0_vm[28]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[28]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 5.498037005409949, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[28]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.9656776626482336, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(31, 28, 19)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c65", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.3418494649701906, - "0_vm[7]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[7]", - "0_vm[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[7]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.3418494649701906, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[7]", - "0_vm[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[7]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 6.467289330533839, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(9, 7, 10)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c66", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 6.458739330533839, - "0_vm[7]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[7]", - "0_vm[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[7]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 6.467289330533839, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[7]", - "0_vm[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[7]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.3418494649701906, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(9, 7, 10)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c67", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.3418494649701906, - "0_vm[10]", - "0_vm[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[10]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[7]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.3418494649701906, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[10]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[7]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 6.467289330533839, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(9, 10, 7)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c68", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 6.458739330533839, - "0_vm[10]", - "0_vm[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[10]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[7]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 6.467289330533839, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[10]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[7]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.3418494649701906, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(9, 10, 7)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c69", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.2592269273704175, - "0_vm[11]", - "0_vm[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[11]", - "0_vm[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[11]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -1.2592269273704175, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[11]", - "0_vm[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[11]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 8.698708713000553, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(14, 11, 18)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c70", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 8.595708713000553, - "0_vm[11]", - "0_vm[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[11]", - "0_vm[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[11]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 8.698708713000553, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[11]", - "0_vm[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[11]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -1.2592269273704175, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(14, 11, 18)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c71", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.2592269273704175, - "0_vm[18]", - "0_vm[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[18]", - "0_vm[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[11]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -1.2592269273704175, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[18]", - "0_vm[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[11]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 8.698708713000553, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(14, 18, 11)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c72", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 8.595708713000553, - "0_vm[18]", - "0_vm[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[18]", - "0_vm[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[11]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 8.698708713000553, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[18]", - "0_vm[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[11]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -1.2592269273704175, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(14, 18, 11)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c73", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.5442206253457624, - "0_vm[3]", - "0_vm[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[3]", - "0_vm[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.5442206253457624, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[3]", - "0_vm[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 17.010777436904807, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(3, 3, 4)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c74", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 16.954277436904807, - "0_vm[3]", - "0_vm[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[3]", - "0_vm[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 17.010777436904807, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[3]", - "0_vm[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.5442206253457624, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(3, 3, 4)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c75", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.5442206253457624, - "0_vm[4]", - "0_vm[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[4]", - "0_vm[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.5442206253457624, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[4]", - "0_vm[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 17.010777436904807, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(3, 4, 3)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c76", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 16.954277436904807, - "0_vm[4]", - "0_vm[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[4]", - "0_vm[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 17.010777436904807, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[4]", - "0_vm[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.5442206253457624, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(3, 4, 3)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c77", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.5382017465334347, - "0_vm[17]", - "0_vm[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[17]", - "0_vm[27]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[17]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[27]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.5382017465334347, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[17]", - "0_vm[27]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[17]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[27]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 1.6861921183958626, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(29, 17, 27)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c78", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.6861921183958626, - "0_vm[17]", - "0_vm[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[17]", - "0_vm[27]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[17]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[27]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 1.6861921183958626, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[17]", - "0_vm[27]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[17]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[27]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.5382017465334347, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(29, 17, 27)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c79", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.5382017465334347, - "0_vm[27]", - "0_vm[27]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[27]", - "0_vm[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[17]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[27]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.5382017465334347, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[27]", - "0_vm[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[17]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[27]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 1.6861921183958626, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(29, 27, 17)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c80", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.6861921183958626, - "0_vm[27]", - "0_vm[27]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[27]", - "0_vm[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[17]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[27]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 1.6861921183958626, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[27]", - "0_vm[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[17]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[27]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.5382017465334347, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(29, 27, 17)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c81", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 10.614654857863137, - "0_vm[6]", - "0_vm[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[6]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[6]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -10.614654857863137, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[6]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[6]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 31.512256609281188, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(7, 6, 7)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c82", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 31.510656609281188, - "0_vm[6]", - "0_vm[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[6]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[6]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 31.512256609281188, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[6]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[6]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -10.614654857863137, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(7, 6, 7)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c83", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 10.614654857863137, - "0_vm[7]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[7]", - "0_vm[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[6]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -10.614654857863137, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[7]", - "0_vm[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[6]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 31.512256609281188, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(7, 7, 6)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c84", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 31.510656609281188, - "0_vm[7]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[7]", - "0_vm[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[6]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 31.512256609281188, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[7]", - "0_vm[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[6]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -10.614654857863137, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(7, 7, 6)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c85", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 4.66785040912336, - "0_vm[22]", - "0_vm[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[22]", - "0_vm[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[23]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -4.66785040912336, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[22]", - "0_vm[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[23]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 8.939086077602251, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(25, 22, 23)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c86", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 8.938436077602251, - "0_vm[22]", - "0_vm[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[22]", - "0_vm[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[23]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 8.939086077602251, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[22]", - "0_vm[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[23]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -4.66785040912336, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(25, 22, 23)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c87", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 4.66785040912336, - "0_vm[23]", - "0_vm[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[23]", - "0_vm[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[23]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -4.66785040912336, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[23]", - "0_vm[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[23]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 8.939086077602251, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(25, 23, 22)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c88", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 8.938436077602251, - "0_vm[23]", - "0_vm[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[23]", - "0_vm[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[23]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 8.939086077602251, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[23]", - "0_vm[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[23]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -4.66785040912336, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(25, 23, 22)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c89", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.434853977156145, - "0_vm[4]", - "0_vm[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[4]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.434853977156145, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[4]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 16.36003009370084, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(4, 4, 5)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c90", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 16.30153009370084, - "0_vm[4]", - "0_vm[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[4]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 16.36003009370084, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[4]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.434853977156145, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(4, 4, 5)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c91", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.434853977156145, - "0_vm[5]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[5]", - "0_vm[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.434853977156145, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[5]", - "0_vm[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 16.36003009370084, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(4, 5, 4)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c92", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 16.30153009370084, - "0_vm[5]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[5]", - "0_vm[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 16.36003009370084, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[5]", - "0_vm[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.434853977156145, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(4, 5, 4)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c93", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.64335500582701, - "0_vm[9]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.64335500582701, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 1.8998888915041532, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(13, 9, 16)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c94", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.8735888915041532, - "0_vm[9]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 1.8998888915041532, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.64335500582701, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(13, 9, 16)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c95", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.64335500582701, - "0_vm[16]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.64335500582701, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 1.8998888915041532, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(13, 16, 9)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c96", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.8735888915041532, - "0_vm[16]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 1.8998888915041532, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.64335500582701, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(13, 16, 9)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c97", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.5424832182137913, - "0_vm[12]", - "0_vm[12]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[12]", - "0_vm[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.5424832182137913, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[12]", - "0_vm[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 7.029547007720768, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(15, 12, 13)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c98", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 7.021647007720768, - "0_vm[12]", - "0_vm[12]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[12]", - "0_vm[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 7.029547007720768, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[12]", - "0_vm[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.5424832182137913, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(15, 12, 13)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c99", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.5424832182137913, - "0_vm[13]", - "0_vm[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[13]", - "0_vm[12]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.5424832182137913, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[13]", - "0_vm[12]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 7.029547007720768, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(15, 13, 12)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c100", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 7.021647007720768, - "0_vm[13]", - "0_vm[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[13]", - "0_vm[12]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 7.029547007720768, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[13]", - "0_vm[12]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.5424832182137913, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(15, 13, 12)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c101", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.070955528571676, - "0_vm[2]", - "0_vm[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[2]", - "0_vm[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -1.070955528571676, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[2]", - "0_vm[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 7.165952433825185, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(2, 2, 3)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c102", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 7.031952433825185, - "0_vm[2]", - "0_vm[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[2]", - "0_vm[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 7.165952433825185, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[2]", - "0_vm[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -1.070955528571676, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(2, 2, 3)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c103", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.070955528571676, - "0_vm[3]", - "0_vm[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[3]", - "0_vm[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -1.070955528571676, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[3]", - "0_vm[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 7.165952433825185, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(2, 3, 2)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c104", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 7.031952433825185, - "0_vm[3]", - "0_vm[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[3]", - "0_vm[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 7.165952433825185, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[3]", - "0_vm[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -1.070955528571676, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(2, 3, 2)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c105", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.4978494338705233, - "0_vm[24]", - "0_vm[24]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[24]", - "0_vm[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -1.4978494338705233, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[24]", - "0_vm[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 2.868957761798156, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(27, 24, 25)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c106", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.866907761798156, - "0_vm[24]", - "0_vm[24]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[24]", - "0_vm[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 2.868957761798156, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[24]", - "0_vm[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -1.4978494338705233, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(27, 24, 25)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c107", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.4978494338705233, - "0_vm[25]", - "0_vm[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[25]", - "0_vm[24]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -1.4978494338705233, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[25]", - "0_vm[24]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 2.868957761798156, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(27, 25, 24)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c108", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.866907761798156, - "0_vm[25]", - "0_vm[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[25]", - "0_vm[24]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 2.868957761798156, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[25]", - "0_vm[24]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -1.4978494338705233, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(27, 25, 24)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c109", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.26161249681590054, - "0_vm[18]", - "0_vm[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[18]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.26161249681590054, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[18]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 11.73125512037617, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(21, 18, 16)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c110", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 11.73125512037617, - "0_vm[18]", - "0_vm[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[18]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 11.73125512037617, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[18]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.26161249681590054, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(21, 18, 16)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c111", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.26161249681590054, - "0_vm[16]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.26161249681590054, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 11.73125512037617, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(21, 16, 18)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c112", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 11.73125512037617, - "0_vm[16]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 11.73125512037617, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.26161249681590054, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(21, 16, 18)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c113", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.9263284811715553, - "0_vm[23]", - "0_vm[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[23]", - "0_vm[24]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.9263284811715553, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[23]", - "0_vm[24]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 5.604798539074481, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(26, 23, 24)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c114", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 5.603748539074481, - "0_vm[23]", - "0_vm[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[23]", - "0_vm[24]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 5.604798539074481, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[23]", - "0_vm[24]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.9263284811715553, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(26, 23, 24)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c115", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.9263284811715553, - "0_vm[24]", - "0_vm[24]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[24]", - "0_vm[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.9263284811715553, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[24]", - "0_vm[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 5.604798539074481, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(26, 24, 23)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c116", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 5.603748539074481, - "0_vm[24]", - "0_vm[24]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[24]", - "0_vm[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 5.604798539074481, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[24]", - "0_vm[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.9263284811715553, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(26, 24, 23)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c117", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.450918029773461, - "0_vm[8]", - "0_vm[8]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[8]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.450918029773461, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[8]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 6.776372942488066, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(10, 8, 9)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c118", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 6.768172942488065, - "0_vm[8]", - "0_vm[8]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[8]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 6.776372942488066, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[8]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.450918029773461, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(10, 8, 9)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c119", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.450918029773461, - "0_vm[9]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[8]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.450918029773461, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[8]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 6.776372942488066, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(10, 9, 8)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c120", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 6.768172942488065, - "0_vm[9]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[8]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 6.776372942488066, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[8]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.450918029773461, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(10, 9, 8)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c121", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.9733135131308841, - "0_vm[14]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[20]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.9733135131308841, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[20]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 2.875699016068521, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(18, 14, 20)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c122", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.8582990160685213, - "0_vm[14]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[20]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 2.875699016068521, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[20]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.9733135131308841, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(18, 14, 20)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c123", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.9733135131308841, - "0_vm[20]", - "0_vm[20]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[20]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.9733135131308841, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[20]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 2.875699016068521, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(18, 20, 14)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c124", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.8582990160685213, - "0_vm[20]", - "0_vm[20]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[20]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 2.875699016068521, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[20]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.9733135131308841, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(18, 20, 14)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c1_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c2_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(5, 5, 6)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(6, 5, 11)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(4, 5, 4)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[5]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c3_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(5, 5, 6)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(6, 5, 11)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(4, 5, 4)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c4_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(20, 16, 17)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(22, 16, 19)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(19, 16, 14)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(13, 16, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(21, 16, 18)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[16]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.21439096103324617 - } - }, - { - "name": "c5_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(20, 16, 17)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(22, 16, 19)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(19, 16, 14)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(13, 16, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(21, 16, 18)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.02572691532398954 - } - }, - { - "name": "c6_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(23, 20, 21)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(18, 20, 14)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[20]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.0015565421870758504 - } - }, - { - "name": "c7_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(23, 20, 21)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(18, 20, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.00018678506244910206 - } - }, - { - "name": "c8_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(15, 12, 13)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(12, 12, 9)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[12]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.05738794110411041 - } - }, - { - "name": "c9_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(15, 12, 13)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(12, 12, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.006886552932493249 - } - }, - { - "name": "c10_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(27, 24, 25)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(26, 24, 23)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[24]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.01804043447630477 - } - }, - { - "name": "c11_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(27, 24, 25)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(26, 24, 23)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.0021648521371565727 - } - }, - { - "name": "c12_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[28]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[30]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[29]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(30, 28, 19)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(31, 28, 19)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[28]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c13_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[28]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[30]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[29]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(30, 28, 19)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(31, 28, 19)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c14_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[25]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(10, 8, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(8, 8, 7)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[8]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c15_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[25]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(10, 8, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(8, 8, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c16_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(29, 17, 27)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(20, 17, 16)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[17]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.267753330934522 - } - }, - { - "name": "c17_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(29, 17, 27)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(20, 17, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.03213039971214264 - } - }, - { - "name": "c18_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[5]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[8]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[1]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[6]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[9]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[3]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[7]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[4]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[2]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[10]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 2)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.6075543555612704 - } - }, - { - "name": "c19_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[5]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[8]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[1]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[6]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[9]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[3]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[7]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[4]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[2]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[10]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.19290652266735245 - } - }, - { - "name": "c20_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[21]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(26, 23, 24)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(25, 23, 22)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[23]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.0004825663866386638 - } - }, - { - "name": "c21_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[21]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(26, 23, 24)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(25, 23, 22)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -5.790796639663966e-5 - } - }, - { - "name": "c22_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[34]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(25, 22, 23)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(24, 22, 21)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[22]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.12074817048704867 - } - }, - { - "name": "c23_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[34]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(25, 22, 23)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(24, 22, 21)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.01448978045844584 - } - }, - { - "name": "c24_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[20]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[32]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[19]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[31]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[33]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(30, 19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(31, 19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(22, 19, 16)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[19]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.4735118986170044 - } - }, - { - "name": "c25_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[20]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[32]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[19]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[31]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[33]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(30, 19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(31, 19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(22, 19, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.1768214278340405 - } - }, - { - "name": "c26_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(7, 6, 7)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(5, 6, 5)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c27_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(7, 6, 7)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(5, 6, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c28_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(14, 11, 18)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(6, 11, 5)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c29_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(14, 11, 18)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(6, 11, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c30_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[16]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[17]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[15]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[18]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(12, 9, 12)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(11, 9, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(13, 9, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(10, 9, 8)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.21593913974111698 - } - }, - { - "name": "c31_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[16]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[17]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[15]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[18]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(12, 9, 12)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(11, 9, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(13, 9, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(10, 9, 8)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.025912696768934037 - } - }, - { - "name": "c32_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(17, 14, 15)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(19, 14, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(18, 14, 20)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(16, 14, 13)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[14]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c33_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(17, 14, 15)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(19, 14, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(18, 14, 20)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(16, 14, 13)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c34_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[12]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[11]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[14]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[13]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 3, 4)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c35_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[12]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[11]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[14]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[13]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 3, 4)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c36_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[24]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(8, 7, 8)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(9, 7, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(7, 7, 6)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c37_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[24]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(8, 7, 8)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(9, 7, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(7, 7, 6)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c38_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(28, 25, 26)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(27, 25, 24)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[25]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.0004825663866386638 - } - }, - { - "name": "c39_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(28, 25, 26)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(27, 25, 24)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -5.790796639663966e-5 - } - }, - { - "name": "c40_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(4, 4, 5)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 4, 3)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.02040724338005229 - } - }, - { - "name": "c41_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(4, 4, 5)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 4, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.002448869205606275 - } - }, - { - "name": "c42_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(16, 13, 14)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(15, 13, 12)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[13]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.0004825663866386638 - } - }, - { - "name": "c43_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(16, 13, 14)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(15, 13, 12)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -5.790796639663966e-5 - } - }, - { - "name": "c44_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(17, 15, 14)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[15]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.10015864047547611 - } - }, - { - "name": "c45_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(17, 15, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.012019036857057132 - } - }, - { - "name": "c46_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(1, 2, 1)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c47_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(1, 2, 1)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c48_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[27]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(29, 27, 17)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[27]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c49_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[27]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(29, 27, 17)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c50_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(24, 21, 22)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(23, 21, 20)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[21]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c51_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(24, 21, 22)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(23, 21, 20)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c52_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[23]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[22]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(28, 26, 25)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[26]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.1700922829782978 - } - }, - { - "name": "c53_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[23]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[22]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(28, 26, 25)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.020411073957395734 - } - }, - { - "name": "c54_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[26]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(11, 10, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(9, 10, 7)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.5563327884359863 - } - }, - { - "name": "c55_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[26]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(11, 10, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(9, 10, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.06675993461231836 - } - }, - { - "name": "c56_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(21, 18, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(14, 18, 11)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[18]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c57_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(21, 18, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(14, 18, 11)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[1]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[1]" - }, - { - "coefficient": -0.0036, - "variable": "outflow[2]" - }, - { - "coefficient": 1.0, - "variable": "spill[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[2]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[2]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[2]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[2]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[2]" - }, - { - "coefficient": 1.0, - "variable": "spill[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[3]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[3]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[3]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[3]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[3]" - }, - { - "coefficient": 1.0, - "variable": "spill[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[4]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[4]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[4]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[4]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[4]" - }, - { - "coefficient": 1.0, - "variable": "spill[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[5]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[5]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[5]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[5]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[5]" - }, - { - "coefficient": 1.0, - "variable": "spill[5]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[6]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[6]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[6]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[6]_out" - }, - { - "coefficient": -0.0036, - "variable": "outflow[5]" - }, - { - "coefficient": 0.0036, - "variable": "outflow[6]" - }, - { - "coefficient": -1.0, - "variable": "spill[5]" - }, - { - "coefficient": 1.0, - "variable": "spill[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[7]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[7]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[7]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[7]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[7]" - }, - { - "coefficient": 1.0, - "variable": "spill[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[8]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[8]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[8]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[8]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[8]" - }, - { - "coefficient": 1.0, - "variable": "spill[8]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[9]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[9]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[9]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[9]_out" - }, - { - "coefficient": -0.0036, - "variable": "outflow[8]" - }, - { - "coefficient": 0.0036, - "variable": "outflow[9]" - }, - { - "coefficient": -1.0, - "variable": "spill[8]" - }, - { - "coefficient": 1.0, - "variable": "spill[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[10]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[10]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[10]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[10]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[10]" - }, - { - "coefficient": 1.0, - "variable": "spill[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[11]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[11]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[11]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[11]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[11]" - }, - { - "coefficient": 1.0, - "variable": "spill[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[1]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[24]" - }, - { - "coefficient": -6.9953, - "variable": "outflow[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[2]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[25]" - }, - { - "coefficient": -5.117, - "variable": "outflow[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[3]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[26]" - }, - { - "coefficient": -9.677, - "variable": "outflow[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[4]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[27]" - }, - { - "coefficient": -5.06, - "variable": "outflow[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[5]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[28]" - }, - { - "coefficient": -8.11, - "variable": "outflow[5]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[6]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[29]" - }, - { - "coefficient": -6.35, - "variable": "outflow[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[7]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[30]" - }, - { - "coefficient": -3.2, - "variable": "outflow[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[8]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[31]" - }, - { - "coefficient": -4.81, - "variable": "outflow[8]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[9]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[32]" - }, - { - "coefficient": -4.47, - "variable": "outflow[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[10]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[33]" - }, - { - "coefficient": -1.2, - "variable": "outflow[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[11]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[34]" - }, - { - "coefficient": -2.5, - "variable": "outflow[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "min_volume_violation_bound[1]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[1]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[2]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[2]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[3]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[3]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[4]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[4]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[5]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[5]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[5]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[6]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[6]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[7]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[7]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[8]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[8]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[8]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[9]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[9]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[10]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[10]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[11]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[11]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[1]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[2]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[2]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[3]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[3]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[4]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[4]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[5]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[5]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[5]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[6]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[6]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[7]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[7]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[8]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[8]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[8]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[9]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[9]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[10]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[10]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[11]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[11]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c1_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[5]" - }, - { - "coefficient": -1.0, - "variable": "0_va[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c2_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[14]" - }, - { - "coefficient": 1.0, - "variable": "0_va[13]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c3_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[16]" - }, - { - "coefficient": -1.0, - "variable": "0_va[17]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c4_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[12]" - }, - { - "coefficient": 1.0, - "variable": "0_va[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c5_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[22]" - }, - { - "coefficient": 1.0, - "variable": "0_va[21]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c6_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[25]" - }, - { - "coefficient": -1.0, - "variable": "0_va[26]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c7_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[8]" - }, - { - "coefficient": 1.0, - "variable": "0_va[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c8_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[14]" - }, - { - "coefficient": -1.0, - "variable": "0_va[15]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c9_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[28]" - }, - { - "coefficient": 1.0, - "variable": "0_va[19]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c10_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[1]" - }, - { - "coefficient": 1.0, - "variable": "0_va[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c11_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[20]" - }, - { - "coefficient": -1.0, - "variable": "0_va[21]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c12_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[16]" - }, - { - "coefficient": -1.0, - "variable": "0_va[19]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c13_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[16]" - }, - { - "coefficient": 1.0, - "variable": "0_va[14]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c14_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[5]" - }, - { - "coefficient": -1.0, - "variable": "0_va[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c15_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[9]" - }, - { - "coefficient": -1.0, - "variable": "0_va[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c16_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[7]" - }, - { - "coefficient": -1.0, - "variable": "0_va[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c17_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[11]" - }, - { - "coefficient": -1.0, - "variable": "0_va[18]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c18_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[3]" - }, - { - "coefficient": -1.0, - "variable": "0_va[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c19_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[17]" - }, - { - "coefficient": -1.0, - "variable": "0_va[27]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c20_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[6]" - }, - { - "coefficient": -1.0, - "variable": "0_va[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c21_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[23]" - }, - { - "coefficient": 1.0, - "variable": "0_va[22]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c22_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[5]" - }, - { - "coefficient": 1.0, - "variable": "0_va[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c23_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[16]" - }, - { - "coefficient": 1.0, - "variable": "0_va[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c24_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[12]" - }, - { - "coefficient": -1.0, - "variable": "0_va[13]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c25_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]" - }, - { - "coefficient": 1.0, - "variable": "0_va[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c26_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[24]" - }, - { - "coefficient": -1.0, - "variable": "0_va[25]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c27_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[16]" - }, - { - "coefficient": 1.0, - "variable": "0_va[18]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c28_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[24]" - }, - { - "coefficient": 1.0, - "variable": "0_va[23]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c29_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[8]" - }, - { - "coefficient": -1.0, - "variable": "0_va[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c30_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[20]" - }, - { - "coefficient": 1.0, - "variable": "0_va[14]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c1_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(5, 5, 6)]", - "variable_2": "0_p[(5, 5, 6)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(5, 5, 6)]", - "variable_2": "0_q[(5, 5, 6)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.48999999999999994 - } - }, - { - "name": "c2_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(5, 6, 5)]", - "variable_2": "0_p[(5, 6, 5)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(5, 6, 5)]", - "variable_2": "0_q[(5, 6, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.48999999999999994 - } - }, - { - "name": "c3_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(16, 13, 14)]", - "variable_2": "0_p[(16, 13, 14)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(16, 13, 14)]", - "variable_2": "0_q[(16, 13, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c4_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(16, 14, 13)]", - "variable_2": "0_p[(16, 14, 13)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(16, 14, 13)]", - "variable_2": "0_q[(16, 14, 13)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c5_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(20, 16, 17)]", - "variable_2": "0_p[(20, 16, 17)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(20, 16, 17)]", - "variable_2": "0_q[(20, 16, 17)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c6_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(20, 17, 16)]", - "variable_2": "0_p[(20, 17, 16)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(20, 17, 16)]", - "variable_2": "0_q[(20, 17, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c7_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(12, 9, 12)]", - "variable_2": "0_p[(12, 9, 12)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(12, 9, 12)]", - "variable_2": "0_q[(12, 9, 12)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c8_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(12, 12, 9)]", - "variable_2": "0_p[(12, 12, 9)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(12, 12, 9)]", - "variable_2": "0_q[(12, 12, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c9_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(24, 21, 22)]", - "variable_2": "0_p[(24, 21, 22)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(24, 21, 22)]", - "variable_2": "0_q[(24, 21, 22)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c10_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(24, 22, 21)]", - "variable_2": "0_p[(24, 22, 21)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(24, 22, 21)]", - "variable_2": "0_q[(24, 22, 21)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c11_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(28, 25, 26)]", - "variable_2": "0_p[(28, 25, 26)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(28, 25, 26)]", - "variable_2": "0_q[(28, 25, 26)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.016900000000000002 - } - }, - { - "name": "c12_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(28, 26, 25)]", - "variable_2": "0_p[(28, 26, 25)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(28, 26, 25)]", - "variable_2": "0_q[(28, 26, 25)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.016900000000000002 - } - }, - { - "name": "c13_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(8, 7, 8)]", - "variable_2": "0_p[(8, 7, 8)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(8, 7, 8)]", - "variable_2": "0_q[(8, 7, 8)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c14_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(8, 8, 7)]", - "variable_2": "0_p[(8, 8, 7)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(8, 8, 7)]", - "variable_2": "0_q[(8, 8, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c15_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(17, 14, 15)]", - "variable_2": "0_p[(17, 14, 15)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(17, 14, 15)]", - "variable_2": "0_q[(17, 14, 15)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "name": "c16_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(17, 15, 14)]", - "variable_2": "0_p[(17, 15, 14)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(17, 15, 14)]", - "variable_2": "0_q[(17, 15, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "name": "c17_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(30, 19, 28)]", - "variable_2": "0_p[(30, 19, 28)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(30, 19, 28)]", - "variable_2": "0_q[(30, 19, 28)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c18_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(30, 28, 19)]", - "variable_2": "0_p[(30, 28, 19)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(30, 28, 19)]", - "variable_2": "0_q[(30, 28, 19)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c19_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 2, 1)]", - "variable_2": "0_p[(1, 2, 1)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 2, 1)]", - "variable_2": "0_q[(1, 2, 1)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.48999999999999994 - } - }, - { - "name": "c20_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 2)]", - "variable_2": "0_p[(1, 1, 2)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 2)]", - "variable_2": "0_q[(1, 1, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.48999999999999994 - } - }, - { - "name": "c21_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(23, 20, 21)]", - "variable_2": "0_p[(23, 20, 21)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(23, 20, 21)]", - "variable_2": "0_q[(23, 20, 21)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.22089999999999999 - } - }, - { - "name": "c22_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(23, 21, 20)]", - "variable_2": "0_p[(23, 21, 20)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(23, 21, 20)]", - "variable_2": "0_q[(23, 21, 20)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.22089999999999999 - } - }, - { - "name": "c23_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(22, 16, 19)]", - "variable_2": "0_p[(22, 16, 19)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(22, 16, 19)]", - "variable_2": "0_q[(22, 16, 19)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.1236000000000002 - } - }, - { - "name": "c24_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(22, 19, 16)]", - "variable_2": "0_p[(22, 19, 16)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(22, 19, 16)]", - "variable_2": "0_q[(22, 19, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.1236000000000002 - } - }, - { - "name": "c25_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(19, 14, 16)]", - "variable_2": "0_p[(19, 14, 16)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(19, 14, 16)]", - "variable_2": "0_q[(19, 14, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c26_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(19, 16, 14)]", - "variable_2": "0_p[(19, 16, 14)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(19, 16, 14)]", - "variable_2": "0_q[(19, 16, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c27_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(6, 5, 11)]", - "variable_2": "0_p[(6, 5, 11)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(6, 5, 11)]", - "variable_2": "0_q[(6, 5, 11)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.6900000000000002 - } - }, - { - "name": "c28_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(6, 11, 5)]", - "variable_2": "0_p[(6, 11, 5)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(6, 11, 5)]", - "variable_2": "0_q[(6, 11, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.6900000000000002 - } - }, - { - "name": "c29_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(11, 9, 10)]", - "variable_2": "0_p[(11, 9, 10)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(11, 9, 10)]", - "variable_2": "0_q[(11, 9, 10)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c30_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(11, 10, 9)]", - "variable_2": "0_p[(11, 10, 9)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(11, 10, 9)]", - "variable_2": "0_q[(11, 10, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c31_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(31, 19, 28)]", - "variable_2": "0_p[(31, 19, 28)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(31, 19, 28)]", - "variable_2": "0_q[(31, 19, 28)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c32_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(31, 28, 19)]", - "variable_2": "0_p[(31, 28, 19)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(31, 28, 19)]", - "variable_2": "0_q[(31, 28, 19)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c33_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(9, 7, 10)]", - "variable_2": "0_p[(9, 7, 10)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(9, 7, 10)]", - "variable_2": "0_q[(9, 7, 10)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c34_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(9, 10, 7)]", - "variable_2": "0_p[(9, 10, 7)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(9, 10, 7)]", - "variable_2": "0_q[(9, 10, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c35_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(14, 11, 18)]", - "variable_2": "0_p[(14, 11, 18)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(14, 11, 18)]", - "variable_2": "0_q[(14, 11, 18)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.6900000000000002 - } - }, - { - "name": "c36_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(14, 18, 11)]", - "variable_2": "0_p[(14, 18, 11)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(14, 18, 11)]", - "variable_2": "0_q[(14, 18, 11)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.6900000000000002 - } - }, - { - "name": "c37_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 3, 4)]", - "variable_2": "0_p[(3, 3, 4)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 3, 4)]", - "variable_2": "0_q[(3, 3, 4)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.6900000000000002 - } - }, - { - "name": "c38_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 4, 3)]", - "variable_2": "0_p[(3, 4, 3)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 4, 3)]", - "variable_2": "0_q[(3, 4, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.6900000000000002 - } - }, - { - "name": "c39_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(29, 17, 27)]", - "variable_2": "0_p[(29, 17, 27)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(29, 17, 27)]", - "variable_2": "0_q[(29, 17, 27)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 4.0 - } - }, - { - "name": "c40_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(29, 27, 17)]", - "variable_2": "0_p[(29, 27, 17)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(29, 27, 17)]", - "variable_2": "0_q[(29, 27, 17)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 4.0 - } - }, - { - "name": "c41_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(7, 6, 7)]", - "variable_2": "0_p[(7, 6, 7)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(7, 6, 7)]", - "variable_2": "0_q[(7, 6, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c42_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(7, 7, 6)]", - "variable_2": "0_p[(7, 7, 6)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(7, 7, 6)]", - "variable_2": "0_q[(7, 7, 6)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c43_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(25, 22, 23)]", - "variable_2": "0_p[(25, 22, 23)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(25, 22, 23)]", - "variable_2": "0_q[(25, 22, 23)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.10890000000000001 - } - }, - { - "name": "c44_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(25, 23, 22)]", - "variable_2": "0_p[(25, 23, 22)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(25, 23, 22)]", - "variable_2": "0_q[(25, 23, 22)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.10890000000000001 - } - }, - { - "name": "c45_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(4, 4, 5)]", - "variable_2": "0_p[(4, 4, 5)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(4, 4, 5)]", - "variable_2": "0_q[(4, 4, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.6900000000000002 - } - }, - { - "name": "c46_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(4, 5, 4)]", - "variable_2": "0_p[(4, 5, 4)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(4, 5, 4)]", - "variable_2": "0_q[(4, 5, 4)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.6900000000000002 - } - }, - { - "name": "c47_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(13, 9, 16)]", - "variable_2": "0_p[(13, 9, 16)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(13, 9, 16)]", - "variable_2": "0_q[(13, 9, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c48_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(13, 16, 9)]", - "variable_2": "0_p[(13, 16, 9)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(13, 16, 9)]", - "variable_2": "0_q[(13, 16, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c49_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(15, 12, 13)]", - "variable_2": "0_p[(15, 12, 13)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(15, 12, 13)]", - "variable_2": "0_q[(15, 12, 13)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c50_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(15, 13, 12)]", - "variable_2": "0_p[(15, 13, 12)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(15, 13, 12)]", - "variable_2": "0_q[(15, 13, 12)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c51_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]", - "variable_2": "0_p[(2, 2, 3)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]", - "variable_2": "0_q[(2, 2, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.6900000000000002 - } - }, - { - "name": "c52_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]", - "variable_2": "0_p[(2, 3, 2)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]", - "variable_2": "0_q[(2, 3, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.6900000000000002 - } - }, - { - "name": "c53_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(27, 24, 25)]", - "variable_2": "0_p[(27, 24, 25)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(27, 24, 25)]", - "variable_2": "0_q[(27, 24, 25)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.016900000000000002 - } - }, - { - "name": "c54_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(27, 25, 24)]", - "variable_2": "0_p[(27, 25, 24)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(27, 25, 24)]", - "variable_2": "0_q[(27, 25, 24)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.016900000000000002 - } - }, - { - "name": "c55_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(21, 18, 16)]", - "variable_2": "0_p[(21, 18, 16)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(21, 18, 16)]", - "variable_2": "0_q[(21, 18, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c56_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(21, 16, 18)]", - "variable_2": "0_p[(21, 16, 18)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(21, 16, 18)]", - "variable_2": "0_q[(21, 16, 18)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c57_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(26, 23, 24)]", - "variable_2": "0_p[(26, 23, 24)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(26, 23, 24)]", - "variable_2": "0_q[(26, 23, 24)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.016900000000000002 - } - }, - { - "name": "c58_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(26, 24, 23)]", - "variable_2": "0_p[(26, 24, 23)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(26, 24, 23)]", - "variable_2": "0_q[(26, 24, 23)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.016900000000000002 - } - }, - { - "name": "c59_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(10, 8, 9)]", - "variable_2": "0_p[(10, 8, 9)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(10, 8, 9)]", - "variable_2": "0_q[(10, 8, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c60_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(10, 9, 8)]", - "variable_2": "0_p[(10, 9, 8)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(10, 9, 8)]", - "variable_2": "0_q[(10, 9, 8)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c61_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(18, 14, 20)]", - "variable_2": "0_p[(18, 14, 20)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(18, 14, 20)]", - "variable_2": "0_q[(18, 14, 20)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.22089999999999999 - } - }, - { - "name": "c62_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(18, 20, 14)]", - "variable_2": "0_p[(18, 20, 14)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(18, 20, 14)]", - "variable_2": "0_q[(18, 20, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.22089999999999999 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[2]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[3]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[4]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[5]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[6]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[7]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[8]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[9]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[10]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[11]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[1]" - }, - "set": { - "type": "EqualTo", - "value": 1.3538975481813056 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[2]" - }, - "set": { - "type": "EqualTo", - "value": 19.68323492663498 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[3]" - }, - "set": { - "type": "EqualTo", - "value": 0.3754523636596491 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[4]" - }, - "set": { - "type": "EqualTo", - "value": 7.658748883214739 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[5]" - }, - "set": { - "type": "EqualTo", - "value": 8.021893816349996 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[6]" - }, - "set": { - "type": "EqualTo", - "value": 12.790574440438007 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[7]" - }, - "set": { - "type": "EqualTo", - "value": 0.4180195852494776 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[8]" - }, - "set": { - "type": "EqualTo", - "value": 11.305606204953921 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[9]" - }, - "set": { - "type": "EqualTo", - "value": 9.120936811607633 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[10]" - }, - "set": { - "type": "EqualTo", - "value": 1.8640401422793809 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[11]" - }, - "set": { - "type": "EqualTo", - "value": 3.327895699300981 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[16]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[20]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[12]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[24]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[28]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[17]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[23]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[22]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[19]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[14]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[25]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[13]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[15]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[27]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[21]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[26]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[18]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[16]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[20]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[12]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[24]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[28]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[17]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[30]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[23]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[32]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[22]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[19]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[31]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[14]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[29]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[33]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[25]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[34]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[13]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[15]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[27]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[21]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[26]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[18]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[5]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[16]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[20]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[12]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[24]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[28]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[8]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[17]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[30]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[23]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[32]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[22]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[6]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[19]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[11]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[31]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[9]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[14]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[29]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[33]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[25]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[7]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[34]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[4]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[13]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[15]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[27]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[21]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[26]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[10]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[18]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(5, 5, 6)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(16, 13, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(20, 16, 17)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(12, 9, 12)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(24, 21, 22)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(28, 25, 26)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(8, 7, 8)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(17, 14, 15)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(30, 19, 28)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 2, 1)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(23, 20, 21)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(22, 16, 19)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(19, 14, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(6, 5, 11)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(11, 9, 10)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(31, 19, 28)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(9, 7, 10)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(14, 11, 18)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 3, 4)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(29, 17, 27)]" - }, - "set": { - "type": "GreaterThan", - "lower": -2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(7, 6, 7)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(25, 22, 23)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(4, 4, 5)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(13, 9, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(15, 12, 13)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(27, 24, 25)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(21, 18, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(26, 23, 24)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(10, 8, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(18, 14, 20)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(5, 6, 5)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(16, 14, 13)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(20, 17, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(12, 12, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(24, 22, 21)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(28, 26, 25)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(8, 8, 7)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(17, 15, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(30, 28, 19)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 2)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(23, 21, 20)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(22, 19, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(19, 16, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(6, 11, 5)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(11, 10, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(31, 28, 19)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(9, 10, 7)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(14, 18, 11)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 4, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(29, 27, 17)]" - }, - "set": { - "type": "GreaterThan", - "lower": -2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(7, 7, 6)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(25, 23, 22)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(4, 5, 4)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(13, 16, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(15, 13, 12)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(27, 25, 24)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(21, 16, 18)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(26, 24, 23)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(10, 9, 8)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(18, 20, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(5, 5, 6)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(16, 13, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(20, 16, 17)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(12, 9, 12)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(24, 21, 22)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(28, 25, 26)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(8, 7, 8)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(17, 14, 15)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(30, 19, 28)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 2, 1)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(23, 20, 21)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(22, 16, 19)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(19, 14, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(6, 5, 11)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(11, 9, 10)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(31, 19, 28)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(9, 7, 10)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(14, 11, 18)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 3, 4)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(29, 17, 27)]" - }, - "set": { - "type": "GreaterThan", - "lower": -2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(7, 6, 7)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(25, 22, 23)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(4, 4, 5)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(13, 9, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(15, 12, 13)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(27, 24, 25)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(21, 18, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(26, 23, 24)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(10, 8, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(18, 14, 20)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(5, 6, 5)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(16, 14, 13)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(20, 17, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(12, 12, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(24, 22, 21)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(28, 26, 25)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(8, 8, 7)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(17, 15, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(30, 28, 19)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 2)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(23, 21, 20)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(22, 19, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(19, 16, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(6, 11, 5)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(11, 10, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(31, 28, 19)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(9, 10, 7)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(14, 18, 11)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 4, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(29, 27, 17)]" - }, - "set": { - "type": "GreaterThan", - "lower": -2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(7, 7, 6)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(25, 23, 22)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(4, 5, 4)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(13, 16, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(15, 13, 12)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(27, 25, 24)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(21, 16, 18)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(26, 24, 23)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(10, 9, 8)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(18, 20, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[2]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[3]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[4]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[5]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[6]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[7]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[8]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[9]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[10]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[11]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[12]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[13]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[14]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[15]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[16]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[17]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[18]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[19]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[20]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[21]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[22]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[23]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[24]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[25]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[26]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[27]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[28]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[5]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[16]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[20]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[12]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[24]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[28]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[8]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[17]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[23]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[22]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[19]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[6]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[11]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[9]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[14]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[7]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[25]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[4]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[13]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[15]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[27]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[21]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[26]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[10]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[18]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[5]" - }, - "set": { - "type": "LessThan", - "upper": 0.153 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[16]" - }, - "set": { - "type": "LessThan", - "upper": 0.149 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[20]" - }, - "set": { - "type": "LessThan", - "upper": 0.07339999999999999 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[12]" - }, - "set": { - "type": "LessThan", - "upper": 0.3381 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[24]" - }, - "set": { - "type": "LessThan", - "upper": 0.72 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[28]" - }, - "set": { - "type": "LessThan", - "upper": 0.7090000000000001 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[8]" - }, - "set": { - "type": "LessThan", - "upper": 0.1888 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[17]" - }, - "set": { - "type": "LessThan", - "upper": 0.149 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[30]" - }, - "set": { - "type": "LessThan", - "upper": 0.04 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]" - }, - "set": { - "type": "LessThan", - "upper": 0.1826 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[23]" - }, - "set": { - "type": "LessThan", - "upper": 0.10800000000000001 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[32]" - }, - "set": { - "type": "LessThan", - "upper": 0.4917 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[22]" - }, - "set": { - "type": "LessThan", - "upper": 0.1494 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[6]" - }, - "set": { - "type": "LessThan", - "upper": 0.1696 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[19]" - }, - "set": { - "type": "LessThan", - "upper": 0.07339999999999999 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[11]" - }, - "set": { - "type": "LessThan", - "upper": 0.3381 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[31]" - }, - "set": { - "type": "LessThan", - "upper": 0.3367 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[9]" - }, - "set": { - "type": "LessThan", - "upper": 0.5175 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[14]" - }, - "set": { - "type": "LessThan", - "upper": 0.4497 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]" - }, - "set": { - "type": "LessThan", - "upper": 0.1523 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[29]" - }, - "set": { - "type": "LessThan", - "upper": 1.08 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[33]" - }, - "set": { - "type": "LessThan", - "upper": 0.0101 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[25]" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[7]" - }, - "set": { - "type": "LessThan", - "upper": 0.1757 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[34]" - }, - "set": { - "type": "LessThan", - "upper": 0.081 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[4]" - }, - "set": { - "type": "LessThan", - "upper": 0.1623 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[13]" - }, - "set": { - "type": "LessThan", - "upper": 0.4497 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[15]" - }, - "set": { - "type": "LessThan", - "upper": 0.1483 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]" - }, - "set": { - "type": "LessThan", - "upper": 0.1593 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[27]" - }, - "set": { - "type": "LessThan", - "upper": 0.184 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[21]" - }, - "set": { - "type": "LessThan", - "upper": 0.1134 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[26]" - }, - "set": { - "type": "LessThan", - "upper": 0.076 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[10]" - }, - "set": { - "type": "LessThan", - "upper": 0.5175 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[18]" - }, - "set": { - "type": "LessThan", - "upper": 0.149 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[5]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[16]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[20]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[12]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[24]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[28]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[8]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[17]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[30]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[23]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[32]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[22]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[6]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[19]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[11]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[31]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[9]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[14]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[29]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[33]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[25]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[7]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[34]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[4]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[13]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[15]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[27]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[21]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[26]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[10]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[18]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(5, 5, 6)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(16, 13, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(20, 16, 17)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(12, 9, 12)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(24, 21, 22)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(28, 25, 26)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(8, 7, 8)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(17, 14, 15)]" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(30, 19, 28)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 2, 1)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(23, 20, 21)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(22, 16, 19)]" - }, - "set": { - "type": "LessThan", - "upper": 1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(19, 14, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(6, 5, 11)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(11, 9, 10)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(31, 19, 28)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(9, 7, 10)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(14, 11, 18)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 3, 4)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(29, 17, 27)]" - }, - "set": { - "type": "LessThan", - "upper": 2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(7, 6, 7)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(25, 22, 23)]" - }, - "set": { - "type": "LessThan", - "upper": 0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(4, 4, 5)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(13, 9, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(15, 12, 13)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(27, 24, 25)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(21, 18, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(26, 23, 24)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(10, 8, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(18, 14, 20)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(5, 6, 5)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(16, 14, 13)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(20, 17, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(12, 12, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(24, 22, 21)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(28, 26, 25)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(8, 8, 7)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(17, 15, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(30, 28, 19)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 2)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(23, 21, 20)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(22, 19, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(19, 16, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(6, 11, 5)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(11, 10, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(31, 28, 19)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(9, 10, 7)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(14, 18, 11)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 4, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(29, 27, 17)]" - }, - "set": { - "type": "LessThan", - "upper": 2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(7, 7, 6)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(25, 23, 22)]" - }, - "set": { - "type": "LessThan", - "upper": 0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(4, 5, 4)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(13, 16, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(15, 13, 12)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(27, 25, 24)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(21, 16, 18)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(26, 24, 23)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(10, 9, 8)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(18, 20, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(5, 5, 6)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(16, 13, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(20, 16, 17)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(12, 9, 12)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(24, 21, 22)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(28, 25, 26)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(8, 7, 8)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(17, 14, 15)]" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(30, 19, 28)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 2, 1)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(23, 20, 21)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(22, 16, 19)]" - }, - "set": { - "type": "LessThan", - "upper": 1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(19, 14, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(6, 5, 11)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(11, 9, 10)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(31, 19, 28)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(9, 7, 10)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(14, 11, 18)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 3, 4)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(29, 17, 27)]" - }, - "set": { - "type": "LessThan", - "upper": 2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(7, 6, 7)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(25, 22, 23)]" - }, - "set": { - "type": "LessThan", - "upper": 0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(4, 4, 5)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(13, 9, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(15, 12, 13)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(27, 24, 25)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(21, 18, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(26, 23, 24)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(10, 8, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(18, 14, 20)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(5, 6, 5)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(16, 14, 13)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(20, 17, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(12, 12, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(24, 22, 21)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(28, 26, 25)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(8, 8, 7)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(17, 15, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(30, 28, 19)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 2)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(23, 21, 20)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(22, 19, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(19, 16, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(6, 11, 5)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(11, 10, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(31, 28, 19)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(9, 10, 7)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(14, 18, 11)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 4, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(29, 27, 17)]" - }, - "set": { - "type": "LessThan", - "upper": 2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(7, 7, 6)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(25, 23, 22)]" - }, - "set": { - "type": "LessThan", - "upper": 0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(4, 5, 4)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(13, 16, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(15, 13, 12)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(27, 25, 24)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(21, 16, 18)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(26, 24, 23)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(10, 9, 8)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(18, 20, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.1 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[2]_out" - }, - "set": { - "type": "LessThan", - "upper": 137.99 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[3]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.042 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[4]_out" - }, - "set": { - "type": "LessThan", - "upper": 16.76 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[5]_out" - }, - "set": { - "type": "LessThan", - "upper": 10.35 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[6]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.32 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[7]_out" - }, - "set": { - "type": "LessThan", - "upper": 9.72 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[8]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.07 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[9]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.04 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[10]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[11]_out" - }, - "set": { - "type": "LessThan", - "upper": 2.93 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]" - }, - "set": { - "type": "LessThan", - "upper": 10.2926 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[2]" - }, - "set": { - "type": "LessThan", - "upper": 10.5531 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[3]" - }, - "set": { - "type": "LessThan", - "upper": 0.7854 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[4]" - }, - "set": { - "type": "LessThan", - "upper": 3.63 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[5]" - }, - "set": { - "type": "LessThan", - "upper": 8.74 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[6]" - }, - "set": { - "type": "LessThan", - "upper": 17.01 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[7]" - }, - "set": { - "type": "LessThan", - "upper": 1.25 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[8]" - }, - "set": { - "type": "LessThan", - "upper": 7.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[9]" - }, - "set": { - "type": "LessThan", - "upper": 11.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[10]" - }, - "set": { - "type": "LessThan", - "upper": 0.84 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[11]" - }, - "set": { - "type": "LessThan", - "upper": 3.24 - } - } - ] -} +{"has_scalar_nonlinear":true,"name":"MathOptFormat Model","version":{"major":1,"minor":7},"variables":[{"name":"0_va[5]","primal_start":0.0},{"name":"0_va[16]","primal_start":0.0},{"name":"0_va[20]","primal_start":0.0},{"name":"0_va[12]","primal_start":0.0},{"name":"0_va[24]","primal_start":0.0},{"name":"0_va[28]","primal_start":0.0},{"name":"0_va[8]","primal_start":0.0},{"name":"0_va[17]","primal_start":0.0},{"name":"0_va[1]","primal_start":0.0},{"name":"0_va[23]","primal_start":0.0},{"name":"0_va[22]","primal_start":0.0},{"name":"0_va[19]","primal_start":0.0},{"name":"0_va[6]","primal_start":0.0},{"name":"0_va[11]","primal_start":0.0},{"name":"0_va[9]","primal_start":0.0},{"name":"0_va[14]","primal_start":0.0},{"name":"0_va[3]","primal_start":0.0},{"name":"0_va[7]","primal_start":0.0},{"name":"0_va[25]","primal_start":0.0},{"name":"0_va[4]","primal_start":0.0},{"name":"0_va[13]","primal_start":0.0},{"name":"0_va[15]","primal_start":0.0},{"name":"0_va[2]","primal_start":0.0},{"name":"0_va[27]","primal_start":0.0},{"name":"0_va[21]","primal_start":0.0},{"name":"0_va[26]","primal_start":0.0},{"name":"0_va[10]","primal_start":0.0},{"name":"0_va[18]","primal_start":0.0},{"name":"0_vm[5]","primal_start":1.0},{"name":"0_vm[16]","primal_start":1.0},{"name":"0_vm[20]","primal_start":1.0},{"name":"0_vm[12]","primal_start":1.0},{"name":"0_vm[24]","primal_start":1.0},{"name":"0_vm[28]","primal_start":1.0},{"name":"0_vm[8]","primal_start":1.0},{"name":"0_vm[17]","primal_start":1.0},{"name":"0_vm[1]","primal_start":1.0},{"name":"0_vm[23]","primal_start":1.0},{"name":"0_vm[22]","primal_start":1.0},{"name":"0_vm[19]","primal_start":1.0},{"name":"0_vm[6]","primal_start":1.0},{"name":"0_vm[11]","primal_start":1.0},{"name":"0_vm[9]","primal_start":1.0},{"name":"0_vm[14]","primal_start":1.0},{"name":"0_vm[3]","primal_start":1.0},{"name":"0_vm[7]","primal_start":1.0},{"name":"0_vm[25]","primal_start":1.0},{"name":"0_vm[4]","primal_start":1.0},{"name":"0_vm[13]","primal_start":1.0},{"name":"0_vm[15]","primal_start":1.0},{"name":"0_vm[2]","primal_start":1.0},{"name":"0_vm[27]","primal_start":1.0},{"name":"0_vm[21]","primal_start":1.0},{"name":"0_vm[26]","primal_start":1.0},{"name":"0_vm[10]","primal_start":1.0},{"name":"0_vm[18]","primal_start":1.0},{"name":"0_pg[5]","primal_start":0.0},{"name":"0_pg[16]","primal_start":0.0},{"name":"0_pg[20]","primal_start":0.0},{"name":"0_pg[12]","primal_start":0.0},{"name":"0_pg[24]","primal_start":0.0},{"name":"0_pg[28]","primal_start":0.0},{"name":"0_pg[8]","primal_start":0.0},{"name":"0_pg[17]","primal_start":0.0},{"name":"0_pg[30]","primal_start":0.0},{"name":"0_pg[1]","primal_start":0.0},{"name":"0_pg[23]","primal_start":0.0},{"name":"0_pg[32]","primal_start":0.0},{"name":"0_pg[22]","primal_start":0.0},{"name":"0_pg[6]","primal_start":0.0},{"name":"0_pg[19]","primal_start":0.0},{"name":"0_pg[11]","primal_start":0.0},{"name":"0_pg[31]","primal_start":0.0},{"name":"0_pg[9]","primal_start":0.0},{"name":"0_pg[14]","primal_start":0.0},{"name":"0_pg[3]","primal_start":0.0},{"name":"0_pg[29]","primal_start":0.0},{"name":"0_pg[33]","primal_start":0.0},{"name":"0_pg[25]","primal_start":0.0},{"name":"0_pg[7]","primal_start":0.0},{"name":"0_pg[34]","primal_start":0.0},{"name":"0_pg[4]","primal_start":0.0},{"name":"0_pg[13]","primal_start":0.0},{"name":"0_pg[15]","primal_start":0.0},{"name":"0_pg[2]","primal_start":0.0},{"name":"0_pg[27]","primal_start":0.0},{"name":"0_pg[21]","primal_start":0.0},{"name":"0_pg[26]","primal_start":0.0},{"name":"0_pg[10]","primal_start":0.0},{"name":"0_pg[18]","primal_start":0.0},{"name":"0_qg[5]","primal_start":0.0},{"name":"0_qg[16]","primal_start":0.0},{"name":"0_qg[20]","primal_start":0.0},{"name":"0_qg[12]","primal_start":0.0},{"name":"0_qg[24]","primal_start":0.0},{"name":"0_qg[28]","primal_start":0.0},{"name":"0_qg[8]","primal_start":0.0},{"name":"0_qg[17]","primal_start":0.0},{"name":"0_qg[30]","primal_start":0.0},{"name":"0_qg[1]","primal_start":0.0},{"name":"0_qg[23]","primal_start":0.0},{"name":"0_qg[32]","primal_start":0.0},{"name":"0_qg[22]","primal_start":0.0},{"name":"0_qg[6]","primal_start":0.0},{"name":"0_qg[19]","primal_start":0.0},{"name":"0_qg[11]","primal_start":0.0},{"name":"0_qg[31]","primal_start":0.0},{"name":"0_qg[9]","primal_start":0.0},{"name":"0_qg[14]","primal_start":0.0},{"name":"0_qg[3]","primal_start":0.0},{"name":"0_qg[29]","primal_start":0.0},{"name":"0_qg[33]","primal_start":0.0},{"name":"0_qg[25]","primal_start":0.0},{"name":"0_qg[7]","primal_start":0.0},{"name":"0_qg[34]","primal_start":0.0},{"name":"0_qg[4]","primal_start":0.0},{"name":"0_qg[13]","primal_start":0.0},{"name":"0_qg[15]","primal_start":0.0},{"name":"0_qg[2]","primal_start":0.0},{"name":"0_qg[27]","primal_start":0.0},{"name":"0_qg[21]","primal_start":0.0},{"name":"0_qg[26]","primal_start":0.0},{"name":"0_qg[10]","primal_start":0.0},{"name":"0_qg[18]","primal_start":0.0},{"name":"0_p[(5, 5, 6)]","primal_start":0.0},{"name":"0_p[(16, 13, 14)]","primal_start":0.0},{"name":"0_p[(20, 16, 17)]","primal_start":0.0},{"name":"0_p[(12, 9, 12)]","primal_start":0.0},{"name":"0_p[(24, 21, 22)]","primal_start":0.0},{"name":"0_p[(28, 25, 26)]","primal_start":0.0},{"name":"0_p[(8, 7, 8)]","primal_start":0.0},{"name":"0_p[(17, 14, 15)]","primal_start":0.0},{"name":"0_p[(30, 19, 28)]","primal_start":0.0},{"name":"0_p[(1, 2, 1)]","primal_start":0.0},{"name":"0_p[(23, 20, 21)]","primal_start":0.0},{"name":"0_p[(22, 16, 19)]","primal_start":0.0},{"name":"0_p[(19, 14, 16)]","primal_start":0.0},{"name":"0_p[(6, 5, 11)]","primal_start":0.0},{"name":"0_p[(11, 9, 10)]","primal_start":0.0},{"name":"0_p[(31, 19, 28)]","primal_start":0.0},{"name":"0_p[(9, 7, 10)]","primal_start":0.0},{"name":"0_p[(14, 11, 18)]","primal_start":0.0},{"name":"0_p[(3, 3, 4)]","primal_start":0.0},{"name":"0_p[(29, 17, 27)]","primal_start":0.0},{"name":"0_p[(7, 6, 7)]","primal_start":0.0},{"name":"0_p[(25, 22, 23)]","primal_start":0.0},{"name":"0_p[(4, 4, 5)]","primal_start":0.0},{"name":"0_p[(13, 9, 16)]","primal_start":0.0},{"name":"0_p[(15, 12, 13)]","primal_start":0.0},{"name":"0_p[(2, 2, 3)]","primal_start":0.0},{"name":"0_p[(27, 24, 25)]","primal_start":0.0},{"name":"0_p[(21, 18, 16)]","primal_start":0.0},{"name":"0_p[(26, 23, 24)]","primal_start":0.0},{"name":"0_p[(10, 8, 9)]","primal_start":0.0},{"name":"0_p[(18, 14, 20)]","primal_start":0.0},{"name":"0_p[(5, 6, 5)]","primal_start":0.0},{"name":"0_p[(16, 14, 13)]","primal_start":0.0},{"name":"0_p[(20, 17, 16)]","primal_start":0.0},{"name":"0_p[(12, 12, 9)]","primal_start":0.0},{"name":"0_p[(24, 22, 21)]","primal_start":0.0},{"name":"0_p[(28, 26, 25)]","primal_start":0.0},{"name":"0_p[(8, 8, 7)]","primal_start":0.0},{"name":"0_p[(17, 15, 14)]","primal_start":0.0},{"name":"0_p[(30, 28, 19)]","primal_start":0.0},{"name":"0_p[(1, 1, 2)]","primal_start":0.0},{"name":"0_p[(23, 21, 20)]","primal_start":0.0},{"name":"0_p[(22, 19, 16)]","primal_start":0.0},{"name":"0_p[(19, 16, 14)]","primal_start":0.0},{"name":"0_p[(6, 11, 5)]","primal_start":0.0},{"name":"0_p[(11, 10, 9)]","primal_start":0.0},{"name":"0_p[(31, 28, 19)]","primal_start":0.0},{"name":"0_p[(9, 10, 7)]","primal_start":0.0},{"name":"0_p[(14, 18, 11)]","primal_start":0.0},{"name":"0_p[(3, 4, 3)]","primal_start":0.0},{"name":"0_p[(29, 27, 17)]","primal_start":0.0},{"name":"0_p[(7, 7, 6)]","primal_start":0.0},{"name":"0_p[(25, 23, 22)]","primal_start":0.0},{"name":"0_p[(4, 5, 4)]","primal_start":0.0},{"name":"0_p[(13, 16, 9)]","primal_start":0.0},{"name":"0_p[(15, 13, 12)]","primal_start":0.0},{"name":"0_p[(2, 3, 2)]","primal_start":0.0},{"name":"0_p[(27, 25, 24)]","primal_start":0.0},{"name":"0_p[(21, 16, 18)]","primal_start":0.0},{"name":"0_p[(26, 24, 23)]","primal_start":0.0},{"name":"0_p[(10, 9, 8)]","primal_start":0.0},{"name":"0_p[(18, 20, 14)]","primal_start":0.0},{"name":"0_q[(5, 5, 6)]","primal_start":0.0},{"name":"0_q[(16, 13, 14)]","primal_start":0.0},{"name":"0_q[(20, 16, 17)]","primal_start":0.0},{"name":"0_q[(12, 9, 12)]","primal_start":0.0},{"name":"0_q[(24, 21, 22)]","primal_start":0.0},{"name":"0_q[(28, 25, 26)]","primal_start":0.0},{"name":"0_q[(8, 7, 8)]","primal_start":0.0},{"name":"0_q[(17, 14, 15)]","primal_start":0.0},{"name":"0_q[(30, 19, 28)]","primal_start":0.0},{"name":"0_q[(1, 2, 1)]","primal_start":0.0},{"name":"0_q[(23, 20, 21)]","primal_start":0.0},{"name":"0_q[(22, 16, 19)]","primal_start":0.0},{"name":"0_q[(19, 14, 16)]","primal_start":0.0},{"name":"0_q[(6, 5, 11)]","primal_start":0.0},{"name":"0_q[(11, 9, 10)]","primal_start":0.0},{"name":"0_q[(31, 19, 28)]","primal_start":0.0},{"name":"0_q[(9, 7, 10)]","primal_start":0.0},{"name":"0_q[(14, 11, 18)]","primal_start":0.0},{"name":"0_q[(3, 3, 4)]","primal_start":0.0},{"name":"0_q[(29, 17, 27)]","primal_start":0.0},{"name":"0_q[(7, 6, 7)]","primal_start":0.0},{"name":"0_q[(25, 22, 23)]","primal_start":0.0},{"name":"0_q[(4, 4, 5)]","primal_start":0.0},{"name":"0_q[(13, 9, 16)]","primal_start":0.0},{"name":"0_q[(15, 12, 13)]","primal_start":0.0},{"name":"0_q[(2, 2, 3)]","primal_start":0.0},{"name":"0_q[(27, 24, 25)]","primal_start":0.0},{"name":"0_q[(21, 18, 16)]","primal_start":0.0},{"name":"0_q[(26, 23, 24)]","primal_start":0.0},{"name":"0_q[(10, 8, 9)]","primal_start":0.0},{"name":"0_q[(18, 14, 20)]","primal_start":0.0},{"name":"0_q[(5, 6, 5)]","primal_start":0.0},{"name":"0_q[(16, 14, 13)]","primal_start":0.0},{"name":"0_q[(20, 17, 16)]","primal_start":0.0},{"name":"0_q[(12, 12, 9)]","primal_start":0.0},{"name":"0_q[(24, 22, 21)]","primal_start":0.0},{"name":"0_q[(28, 26, 25)]","primal_start":0.0},{"name":"0_q[(8, 8, 7)]","primal_start":0.0},{"name":"0_q[(17, 15, 14)]","primal_start":0.0},{"name":"0_q[(30, 28, 19)]","primal_start":0.0},{"name":"0_q[(1, 1, 2)]","primal_start":0.0},{"name":"0_q[(23, 21, 20)]","primal_start":0.0},{"name":"0_q[(22, 19, 16)]","primal_start":0.0},{"name":"0_q[(19, 16, 14)]","primal_start":0.0},{"name":"0_q[(6, 11, 5)]","primal_start":0.0},{"name":"0_q[(11, 10, 9)]","primal_start":0.0},{"name":"0_q[(31, 28, 19)]","primal_start":0.0},{"name":"0_q[(9, 10, 7)]","primal_start":0.0},{"name":"0_q[(14, 18, 11)]","primal_start":0.0},{"name":"0_q[(3, 4, 3)]","primal_start":0.0},{"name":"0_q[(29, 27, 17)]","primal_start":0.0},{"name":"0_q[(7, 7, 6)]","primal_start":0.0},{"name":"0_q[(25, 23, 22)]","primal_start":0.0},{"name":"0_q[(4, 5, 4)]","primal_start":0.0},{"name":"0_q[(13, 16, 9)]","primal_start":0.0},{"name":"0_q[(15, 13, 12)]","primal_start":0.0},{"name":"0_q[(2, 3, 2)]","primal_start":0.0},{"name":"0_q[(27, 25, 24)]","primal_start":0.0},{"name":"0_q[(21, 16, 18)]","primal_start":0.0},{"name":"0_q[(26, 24, 23)]","primal_start":0.0},{"name":"0_q[(10, 9, 8)]","primal_start":0.0},{"name":"0_q[(18, 20, 14)]","primal_start":0.0},{"name":"reservoir[1]_in","primal_start":0.0},{"name":"reservoir[1]_out","primal_start":0.0},{"name":"reservoir[2]_in","primal_start":0.0},{"name":"reservoir[2]_out","primal_start":0.0},{"name":"reservoir[3]_in","primal_start":0.0},{"name":"reservoir[3]_out","primal_start":0.0},{"name":"reservoir[4]_in","primal_start":0.0},{"name":"reservoir[4]_out","primal_start":0.0},{"name":"reservoir[5]_in","primal_start":0.0},{"name":"reservoir[5]_out","primal_start":0.0},{"name":"reservoir[6]_in","primal_start":0.0},{"name":"reservoir[6]_out","primal_start":0.0},{"name":"reservoir[7]_in","primal_start":0.0},{"name":"reservoir[7]_out","primal_start":0.0},{"name":"reservoir[8]_in","primal_start":0.0},{"name":"reservoir[8]_out","primal_start":0.0},{"name":"reservoir[9]_in","primal_start":0.0},{"name":"reservoir[9]_out","primal_start":0.0},{"name":"reservoir[10]_in","primal_start":0.0},{"name":"reservoir[10]_out","primal_start":0.0},{"name":"reservoir[11]_in","primal_start":0.0},{"name":"reservoir[11]_out","primal_start":0.0},{"name":"min_volume_violation[1]","primal_start":0.0},{"name":"min_volume_violation[2]","primal_start":0.0},{"name":"min_volume_violation[3]","primal_start":0.0},{"name":"min_volume_violation[4]","primal_start":0.0},{"name":"min_volume_violation[5]","primal_start":0.0},{"name":"min_volume_violation[6]","primal_start":0.0},{"name":"min_volume_violation[7]","primal_start":0.0},{"name":"min_volume_violation[8]","primal_start":0.0},{"name":"min_volume_violation[9]","primal_start":0.0},{"name":"min_volume_violation[10]","primal_start":0.0},{"name":"min_volume_violation[11]","primal_start":0.0},{"name":"outflow[1]","primal_start":0.0},{"name":"outflow[2]","primal_start":0.0},{"name":"outflow[3]","primal_start":0.0},{"name":"outflow[4]","primal_start":0.0},{"name":"outflow[5]","primal_start":0.0},{"name":"outflow[6]","primal_start":0.0},{"name":"outflow[7]","primal_start":0.0},{"name":"outflow[8]","primal_start":0.0},{"name":"outflow[9]","primal_start":0.0},{"name":"outflow[10]","primal_start":0.0},{"name":"outflow[11]","primal_start":0.0},{"name":"spill[1]","primal_start":0.0},{"name":"spill[2]","primal_start":0.0},{"name":"spill[3]","primal_start":0.0},{"name":"spill[4]","primal_start":0.0},{"name":"spill[5]","primal_start":0.0},{"name":"spill[6]","primal_start":0.0},{"name":"spill[7]","primal_start":0.0},{"name":"spill[8]","primal_start":0.0},{"name":"spill[9]","primal_start":0.0},{"name":"spill[10]","primal_start":0.0},{"name":"spill[11]","primal_start":0.0},{"name":"min_outflow_violation[1]","primal_start":0.0},{"name":"min_outflow_violation[2]","primal_start":0.0},{"name":"min_outflow_violation[3]","primal_start":0.0},{"name":"min_outflow_violation[4]","primal_start":0.0},{"name":"min_outflow_violation[5]","primal_start":0.0},{"name":"min_outflow_violation[6]","primal_start":0.0},{"name":"min_outflow_violation[7]","primal_start":0.0},{"name":"min_outflow_violation[8]","primal_start":0.0},{"name":"min_outflow_violation[9]","primal_start":0.0},{"name":"min_outflow_violation[10]","primal_start":0.0},{"name":"min_outflow_violation[11]","primal_start":0.0},{"name":"inflow[1]","primal_start":0.0},{"name":"inflow[2]","primal_start":0.0},{"name":"inflow[3]","primal_start":0.0},{"name":"inflow[4]","primal_start":0.0},{"name":"inflow[5]","primal_start":0.0},{"name":"inflow[6]","primal_start":0.0},{"name":"inflow[7]","primal_start":0.0},{"name":"inflow[8]","primal_start":0.0},{"name":"inflow[9]","primal_start":0.0},{"name":"inflow[10]","primal_start":0.0},{"name":"inflow[11]","primal_start":0.0},{"name":"deficit[1]","primal_start":0.0},{"name":"deficit[2]","primal_start":0.0},{"name":"deficit[3]","primal_start":0.0},{"name":"deficit[4]","primal_start":0.0},{"name":"deficit[5]","primal_start":0.0},{"name":"deficit[6]","primal_start":0.0},{"name":"deficit[7]","primal_start":0.0},{"name":"deficit[8]","primal_start":0.0},{"name":"deficit[9]","primal_start":0.0},{"name":"deficit[10]","primal_start":0.0},{"name":"deficit[11]","primal_start":0.0},{"name":"deficit[12]","primal_start":0.0},{"name":"deficit[13]","primal_start":0.0},{"name":"deficit[14]","primal_start":0.0},{"name":"deficit[15]","primal_start":0.0},{"name":"deficit[16]","primal_start":0.0},{"name":"deficit[17]","primal_start":0.0},{"name":"deficit[18]","primal_start":0.0},{"name":"deficit[19]","primal_start":0.0},{"name":"deficit[20]","primal_start":0.0},{"name":"deficit[21]","primal_start":0.0},{"name":"deficit[22]","primal_start":0.0},{"name":"deficit[23]","primal_start":0.0},{"name":"deficit[24]","primal_start":0.0},{"name":"deficit[25]","primal_start":0.0},{"name":"deficit[26]","primal_start":0.0},{"name":"deficit[27]","primal_start":0.0},{"name":"deficit[28]","primal_start":0.0}],"objective":{"sense":"min","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":6000.0,"variable":"deficit[1]"},{"coefficient":6000.0,"variable":"deficit[2]"},{"coefficient":6000.0,"variable":"deficit[3]"},{"coefficient":6000.0,"variable":"deficit[4]"},{"coefficient":6000.0,"variable":"deficit[5]"},{"coefficient":6000.0,"variable":"deficit[6]"},{"coefficient":6000.0,"variable":"deficit[7]"},{"coefficient":6000.0,"variable":"deficit[8]"},{"coefficient":6000.0,"variable":"deficit[9]"},{"coefficient":6000.0,"variable":"deficit[10]"},{"coefficient":6000.0,"variable":"deficit[11]"},{"coefficient":6000.0,"variable":"deficit[12]"},{"coefficient":6000.0,"variable":"deficit[13]"},{"coefficient":6000.0,"variable":"deficit[14]"},{"coefficient":6000.0,"variable":"deficit[15]"},{"coefficient":6000.0,"variable":"deficit[16]"},{"coefficient":6000.0,"variable":"deficit[17]"},{"coefficient":6000.0,"variable":"deficit[18]"},{"coefficient":6000.0,"variable":"deficit[19]"},{"coefficient":6000.0,"variable":"deficit[20]"},{"coefficient":6000.0,"variable":"deficit[21]"},{"coefficient":6000.0,"variable":"deficit[22]"},{"coefficient":6000.0,"variable":"deficit[23]"},{"coefficient":6000.0,"variable":"deficit[24]"},{"coefficient":6000.0,"variable":"deficit[25]"},{"coefficient":6000.0,"variable":"deficit[26]"},{"coefficient":6000.0,"variable":"deficit[27]"},{"coefficient":6000.0,"variable":"deficit[28]"},{"coefficient":2268.0,"variable":"0_pg[5]"},{"coefficient":2059.0,"variable":"0_pg[16]"},{"coefficient":1780.0,"variable":"0_pg[20]"},{"coefficient":1576.0,"variable":"0_pg[12]"},{"coefficient":10.0,"variable":"0_pg[24]"},{"coefficient":10.0,"variable":"0_pg[28]"},{"coefficient":1754.0,"variable":"0_pg[8]"},{"coefficient":2059.0,"variable":"0_pg[17]"},{"coefficient":10.0,"variable":"0_pg[30]"},{"coefficient":1918.0,"variable":"0_pg[1]"},{"coefficient":4244.0,"variable":"0_pg[23]"},{"coefficient":10.0,"variable":"0_pg[32]"},{"coefficient":1517.0,"variable":"0_pg[22]"},{"coefficient":2131.0,"variable":"0_pg[6]"},{"coefficient":1780.0,"variable":"0_pg[19]"},{"coefficient":1576.0,"variable":"0_pg[11]"},{"coefficient":10.0,"variable":"0_pg[31]"},{"coefficient":1576.0,"variable":"0_pg[9]"},{"coefficient":1404.0,"variable":"0_pg[14]"},{"coefficient":2184.0,"variable":"0_pg[3]"},{"coefficient":10.0,"variable":"0_pg[29]"},{"coefficient":10.0,"variable":"0_pg[33]"},{"coefficient":10.0,"variable":"0_pg[25]"},{"coefficient":1822.0,"variable":"0_pg[7]"},{"coefficient":10.0,"variable":"0_pg[34]"},{"coefficient":2179.0,"variable":"0_pg[4]"},{"coefficient":1404.0,"variable":"0_pg[13]"},{"coefficient":2077.0,"variable":"0_pg[15]"},{"coefficient":2120.0,"variable":"0_pg[2]"},{"coefficient":10.0,"variable":"0_pg[27]"},{"coefficient":1598.0,"variable":"0_pg[21]"},{"coefficient":10.0,"variable":"0_pg[26]"},{"coefficient":1576.0,"variable":"0_pg[10]"},{"coefficient":2059.0,"variable":"0_pg[18]"}],"constant":0.0}},"constraints":[{"name":"c1","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[0.4213950047523992,"0_vm[5]","0_vm[5]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[5]","0_vm[6]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[5]"]},{"type":"*","args":[-1.0,"0_va[6]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[12.485777918589607,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[5]","0_vm[6]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[1.0,"0_va[5]"]},{"type":"*","args":[-1.0,"0_va[6]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.4213950047523992,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(5, 5, 6)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c2","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[12.485777918589607,"0_vm[5]","0_vm[5]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[5]","0_vm[6]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[5]"]},{"type":"*","args":[-1.0,"0_va[6]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[12.485777918589607,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[5]","0_vm[6]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[1.0,"0_va[5]"]},{"type":"*","args":[-1.0,"0_va[6]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-0.4213950047523992,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(5, 5, 6)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c3","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[0.4213950047523992,"0_vm[6]","0_vm[6]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[6]","0_vm[5]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[5]"]},{"type":"*","args":[1.0,"0_va[6]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[12.485777918589607,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[6]","0_vm[5]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[-1.0,"0_va[5]"]},{"type":"*","args":[1.0,"0_va[6]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.4213950047523992,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(5, 6, 5)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c4","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[12.485777918589607,"0_vm[6]","0_vm[6]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[6]","0_vm[5]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[5]"]},{"type":"*","args":[1.0,"0_va[6]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[12.485777918589607,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[6]","0_vm[5]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[-1.0,"0_va[5]"]},{"type":"*","args":[1.0,"0_va[6]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-0.4213950047523992,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(5, 6, 5)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c5","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[2.46024690223052,"0_vm[13]","0_vm[13]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[13]","0_vm[14]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[14]"]},{"type":"*","args":[1.0,"0_va[13]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[6.795713842466891,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[13]","0_vm[14]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[-1.0,"0_va[14]"]},{"type":"*","args":[1.0,"0_va[13]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.46024690223052,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(16, 13, 14)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c6","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[6.787563842466891,"0_vm[13]","0_vm[13]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[13]","0_vm[14]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[14]"]},{"type":"*","args":[1.0,"0_va[13]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[6.795713842466891,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[13]","0_vm[14]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[-1.0,"0_va[14]"]},{"type":"*","args":[1.0,"0_va[13]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-2.46024690223052,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(16, 13, 14)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c7","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[2.46024690223052,"0_vm[14]","0_vm[14]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[14]","0_vm[13]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[14]"]},{"type":"*","args":[-1.0,"0_va[13]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[6.795713842466891,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[14]","0_vm[13]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[1.0,"0_va[14]"]},{"type":"*","args":[-1.0,"0_va[13]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.46024690223052,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(16, 14, 13)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c8","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[6.787563842466891,"0_vm[14]","0_vm[14]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[14]","0_vm[13]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[14]"]},{"type":"*","args":[-1.0,"0_va[13]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[6.795713842466891,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[14]","0_vm[13]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[1.0,"0_va[14]"]},{"type":"*","args":[-1.0,"0_va[13]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-2.46024690223052,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(16, 14, 13)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c9","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[0.7456627284627748,"0_vm[16]","0_vm[16]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[16]","0_vm[17]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[16]"]},{"type":"*","args":[-1.0,"0_va[17]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[10.149298248521102,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[16]","0_vm[17]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[1.0,"0_va[16]"]},{"type":"*","args":[-1.0,"0_va[17]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.7456627284627748,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(20, 16, 17)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c10","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[10.149298248521102,"0_vm[16]","0_vm[16]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[16]","0_vm[17]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[16]"]},{"type":"*","args":[-1.0,"0_va[17]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[10.149298248521102,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[16]","0_vm[17]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[1.0,"0_va[16]"]},{"type":"*","args":[-1.0,"0_va[17]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-0.7456627284627748,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(20, 16, 17)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c11","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[0.7456627284627748,"0_vm[17]","0_vm[17]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[17]","0_vm[16]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[16]"]},{"type":"*","args":[1.0,"0_va[17]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[10.149298248521102,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[17]","0_vm[16]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[-1.0,"0_va[16]"]},{"type":"*","args":[1.0,"0_va[17]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.7456627284627748,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(20, 17, 16)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c12","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[10.149298248521102,"0_vm[17]","0_vm[17]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[17]","0_vm[16]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[16]"]},{"type":"*","args":[1.0,"0_va[17]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[10.149298248521102,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[17]","0_vm[16]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[-1.0,"0_va[16]"]},{"type":"*","args":[1.0,"0_va[17]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-0.7456627284627748,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(20, 17, 16)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c13","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[2.3473152225768015,"0_vm[9]","0_vm[9]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[9]","0_vm[12]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[12]"]},{"type":"*","args":[1.0,"0_va[9]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[6.481250938450924,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[9]","0_vm[12]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[-1.0,"0_va[12]"]},{"type":"*","args":[1.0,"0_va[9]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.3473152225768015,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(12, 9, 12)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c14","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[6.472700938450925,"0_vm[9]","0_vm[9]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[9]","0_vm[12]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[12]"]},{"type":"*","args":[1.0,"0_va[9]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[6.481250938450924,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[9]","0_vm[12]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[-1.0,"0_va[12]"]},{"type":"*","args":[1.0,"0_va[9]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-2.3473152225768015,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(12, 9, 12)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c15","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[2.3473152225768015,"0_vm[12]","0_vm[12]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[12]","0_vm[9]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[12]"]},{"type":"*","args":[-1.0,"0_va[9]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[6.481250938450924,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[12]","0_vm[9]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[1.0,"0_va[12]"]},{"type":"*","args":[-1.0,"0_va[9]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.3473152225768015,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(12, 12, 9)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c16","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[6.472700938450925,"0_vm[12]","0_vm[12]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[12]","0_vm[9]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[12]"]},{"type":"*","args":[-1.0,"0_va[9]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[6.481250938450924,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[12]","0_vm[9]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[1.0,"0_va[12]"]},{"type":"*","args":[-1.0,"0_va[9]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-2.3473152225768015,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(12, 12, 9)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c17","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[0.13631367642289954,"0_vm[21]","0_vm[21]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[21]","0_vm[22]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[22]"]},{"type":"*","args":[1.0,"0_va[21]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[4.2328983731321435,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[21]","0_vm[22]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[-1.0,"0_va[22]"]},{"type":"*","args":[1.0,"0_va[21]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.13631367642289954,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(24, 21, 22)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c18","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[4.2328983731321435,"0_vm[21]","0_vm[21]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[21]","0_vm[22]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[22]"]},{"type":"*","args":[1.0,"0_va[21]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[4.2328983731321435,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[21]","0_vm[22]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[-1.0,"0_va[22]"]},{"type":"*","args":[1.0,"0_va[21]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-0.13631367642289954,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(24, 21, 22)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c19","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[0.13631367642289954,"0_vm[22]","0_vm[22]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[22]","0_vm[21]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[22]"]},{"type":"*","args":[-1.0,"0_va[21]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[4.2328983731321435,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[22]","0_vm[21]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[1.0,"0_va[22]"]},{"type":"*","args":[-1.0,"0_va[21]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.13631367642289954,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(24, 22, 21)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c20","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[4.2328983731321435,"0_vm[22]","0_vm[22]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[22]","0_vm[21]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[22]"]},{"type":"*","args":[-1.0,"0_va[21]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[4.2328983731321435,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[22]","0_vm[21]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[1.0,"0_va[22]"]},{"type":"*","args":[-1.0,"0_va[21]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-0.13631367642289954,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(24, 22, 21)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c21","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[1.0916977112407253,"0_vm[25]","0_vm[25]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[25]","0_vm[26]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[25]"]},{"type":"*","args":[-1.0,"0_va[26]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[2.091029561081878,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[25]","0_vm[26]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[1.0,"0_va[25]"]},{"type":"*","args":[-1.0,"0_va[26]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-1.0916977112407253,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(28, 25, 26)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c22","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[2.088179561081878,"0_vm[25]","0_vm[25]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[25]","0_vm[26]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[25]"]},{"type":"*","args":[-1.0,"0_va[26]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[2.091029561081878,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[25]","0_vm[26]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[1.0,"0_va[25]"]},{"type":"*","args":[-1.0,"0_va[26]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-1.0916977112407253,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(28, 25, 26)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c23","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[1.0916977112407253,"0_vm[26]","0_vm[26]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[26]","0_vm[25]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[25]"]},{"type":"*","args":[1.0,"0_va[26]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[2.091029561081878,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[26]","0_vm[25]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[-1.0,"0_va[25]"]},{"type":"*","args":[1.0,"0_va[26]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-1.0916977112407253,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(28, 26, 25)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c24","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[2.088179561081878,"0_vm[26]","0_vm[26]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[26]","0_vm[25]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[25]"]},{"type":"*","args":[1.0,"0_va[26]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[2.091029561081878,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[26]","0_vm[25]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[-1.0,"0_va[25]"]},{"type":"*","args":[1.0,"0_va[26]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-1.0916977112407253,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(28, 26, 25)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c25","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[15.980730481506358,"0_vm[7]","0_vm[7]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[7]","0_vm[8]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[8]"]},{"type":"*","args":[1.0,"0_va[7]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[45.39453875906154,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[7]","0_vm[8]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[-1.0,"0_va[8]"]},{"type":"*","args":[1.0,"0_va[7]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-15.980730481506358,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(8, 7, 8)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c26","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[45.39333875906154,"0_vm[7]","0_vm[7]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[7]","0_vm[8]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[8]"]},{"type":"*","args":[1.0,"0_va[7]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[45.39453875906154,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[7]","0_vm[8]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[-1.0,"0_va[8]"]},{"type":"*","args":[1.0,"0_va[7]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-15.980730481506358,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(8, 7, 8)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c27","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[15.980730481506358,"0_vm[8]","0_vm[8]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[8]","0_vm[7]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[8]"]},{"type":"*","args":[-1.0,"0_va[7]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[45.39453875906154,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[8]","0_vm[7]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[1.0,"0_va[8]"]},{"type":"*","args":[-1.0,"0_va[7]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-15.980730481506358,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(8, 8, 7)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c28","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[45.39333875906154,"0_vm[8]","0_vm[8]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[8]","0_vm[7]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[8]"]},{"type":"*","args":[-1.0,"0_va[7]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[45.39453875906154,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[8]","0_vm[7]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[1.0,"0_va[8]"]},{"type":"*","args":[-1.0,"0_va[7]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-15.980730481506358,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(8, 8, 7)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c29","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[1.4325735387749903,"0_vm[14]","0_vm[14]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[14]","0_vm[15]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[14]"]},{"type":"*","args":[-1.0,"0_va[15]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[19.8968547052082,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[14]","0_vm[15]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[1.0,"0_va[14]"]},{"type":"*","args":[-1.0,"0_va[15]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-1.4325735387749903,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(17, 14, 15)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c30","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[19.8968547052082,"0_vm[14]","0_vm[14]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[14]","0_vm[15]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[14]"]},{"type":"*","args":[-1.0,"0_va[15]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[19.8968547052082,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[14]","0_vm[15]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[1.0,"0_va[14]"]},{"type":"*","args":[-1.0,"0_va[15]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-1.4325735387749903,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(17, 14, 15)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c31","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[1.4325735387749903,"0_vm[15]","0_vm[15]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[15]","0_vm[14]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[14]"]},{"type":"*","args":[1.0,"0_va[15]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[19.8968547052082,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[15]","0_vm[14]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[-1.0,"0_va[14]"]},{"type":"*","args":[1.0,"0_va[15]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-1.4325735387749903,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(17, 15, 14)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c32","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[19.8968547052082,"0_vm[15]","0_vm[15]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[15]","0_vm[14]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[14]"]},{"type":"*","args":[1.0,"0_va[15]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[19.8968547052082,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[15]","0_vm[14]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[-1.0,"0_va[14]"]},{"type":"*","args":[1.0,"0_va[15]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-1.4325735387749903,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(17, 15, 14)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c33","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[0.8777625235737184,"0_vm[19]","0_vm[19]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[19]","0_vm[28]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[28]"]},{"type":"*","args":[1.0,"0_va[19]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[9.121944633618186,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[19]","0_vm[28]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[-1.0,"0_va[28]"]},{"type":"*","args":[1.0,"0_va[19]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.8777625235737184,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(30, 19, 28)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c34","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[9.097144633618186,"0_vm[19]","0_vm[19]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[19]","0_vm[28]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[28]"]},{"type":"*","args":[1.0,"0_va[19]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[9.121944633618186,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[19]","0_vm[28]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[-1.0,"0_va[28]"]},{"type":"*","args":[1.0,"0_va[19]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-0.8777625235737184,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(30, 19, 28)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c35","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[0.8777625235737184,"0_vm[28]","0_vm[28]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[28]","0_vm[19]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[28]"]},{"type":"*","args":[-1.0,"0_va[19]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[9.121944633618186,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[28]","0_vm[19]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[1.0,"0_va[28]"]},{"type":"*","args":[-1.0,"0_va[19]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.8777625235737184,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(30, 28, 19)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c36","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[9.097144633618186,"0_vm[28]","0_vm[28]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[28]","0_vm[19]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[28]"]},{"type":"*","args":[-1.0,"0_va[19]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[9.121944633618186,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[28]","0_vm[19]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[1.0,"0_va[28]"]},{"type":"*","args":[-1.0,"0_va[19]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-0.8777625235737184,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(30, 28, 19)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c37","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[0.28958087993976717,"0_vm[2]","0_vm[2]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[2]","0_vm[1]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[1]"]},{"type":"*","args":[1.0,"0_va[2]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[9.363115118052471,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[2]","0_vm[1]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[-1.0,"0_va[1]"]},{"type":"*","args":[1.0,"0_va[2]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.28958087993976717,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(1, 2, 1)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c38","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[9.363115118052471,"0_vm[2]","0_vm[2]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[2]","0_vm[1]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[1]"]},{"type":"*","args":[1.0,"0_va[2]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[9.363115118052471,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[2]","0_vm[1]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[-1.0,"0_va[1]"]},{"type":"*","args":[1.0,"0_va[2]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-0.28958087993976717,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(1, 2, 1)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c39","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[0.28958087993976717,"0_vm[1]","0_vm[1]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[1]","0_vm[2]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[1]"]},{"type":"*","args":[-1.0,"0_va[2]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[9.363115118052471,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[1]","0_vm[2]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[1.0,"0_va[1]"]},{"type":"*","args":[-1.0,"0_va[2]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.28958087993976717,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(1, 1, 2)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c40","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[9.363115118052471,"0_vm[1]","0_vm[1]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[1]","0_vm[2]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[1]"]},{"type":"*","args":[-1.0,"0_va[2]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[9.363115118052471,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[1]","0_vm[2]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[1.0,"0_va[1]"]},{"type":"*","args":[-1.0,"0_va[2]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-0.28958087993976717,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(1, 1, 2)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c41","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[1.128676282013955,"0_vm[20]","0_vm[20]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[20]","0_vm[21]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[20]"]},{"type":"*","args":[-1.0,"0_va[21]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[3.33399327650884,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[20]","0_vm[21]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[1.0,"0_va[20]"]},{"type":"*","args":[-1.0,"0_va[21]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-1.128676282013955,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(23, 20, 21)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c42","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[3.3189932765088397,"0_vm[20]","0_vm[20]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[20]","0_vm[21]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[20]"]},{"type":"*","args":[-1.0,"0_va[21]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[3.33399327650884,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[20]","0_vm[21]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[1.0,"0_va[20]"]},{"type":"*","args":[-1.0,"0_va[21]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-1.128676282013955,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(23, 20, 21)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c43","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[1.128676282013955,"0_vm[21]","0_vm[21]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[21]","0_vm[20]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[20]"]},{"type":"*","args":[1.0,"0_va[21]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[3.33399327650884,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[21]","0_vm[20]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[-1.0,"0_va[20]"]},{"type":"*","args":[1.0,"0_va[21]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-1.128676282013955,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(23, 21, 20)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c44","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[3.3189932765088397,"0_vm[21]","0_vm[21]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[21]","0_vm[20]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[20]"]},{"type":"*","args":[1.0,"0_va[21]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[3.33399327650884,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[21]","0_vm[20]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[-1.0,"0_va[20]"]},{"type":"*","args":[1.0,"0_va[21]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-1.128676282013955,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(23, 21, 20)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c45","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[0.8287243608560181,"0_vm[16]","0_vm[16]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[16]","0_vm[19]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[16]"]},{"type":"*","args":[-1.0,"0_va[19]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[2.8140484527509644,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[16]","0_vm[19]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[1.0,"0_va[16]"]},{"type":"*","args":[-1.0,"0_va[19]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.8287243608560181,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(22, 16, 19)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c46","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[2.7777484527509646,"0_vm[16]","0_vm[16]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[16]","0_vm[19]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[16]"]},{"type":"*","args":[-1.0,"0_va[19]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[2.8140484527509644,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[16]","0_vm[19]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[1.0,"0_va[16]"]},{"type":"*","args":[-1.0,"0_va[19]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-0.8287243608560181,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(22, 16, 19)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c47","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[0.8287243608560181,"0_vm[19]","0_vm[19]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[19]","0_vm[16]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[16]"]},{"type":"*","args":[1.0,"0_va[19]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[2.8140484527509644,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[19]","0_vm[16]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[-1.0,"0_va[16]"]},{"type":"*","args":[1.0,"0_va[19]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.8287243608560181,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(22, 19, 16)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c48","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[2.7777484527509646,"0_vm[19]","0_vm[19]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[19]","0_vm[16]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[16]"]},{"type":"*","args":[1.0,"0_va[19]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[2.8140484527509644,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[19]","0_vm[16]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[-1.0,"0_va[16]"]},{"type":"*","args":[1.0,"0_va[19]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-0.8287243608560181,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(22, 19, 16)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c49","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[1.2416585439004273,"0_vm[14]","0_vm[14]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[14]","0_vm[16]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[16]"]},{"type":"*","args":[1.0,"0_va[14]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[3.667991302391842,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[14]","0_vm[16]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[-1.0,"0_va[16]"]},{"type":"*","args":[1.0,"0_va[14]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-1.2416585439004273,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(19, 14, 16)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c50","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[3.654341302391842,"0_vm[14]","0_vm[14]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[14]","0_vm[16]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[16]"]},{"type":"*","args":[1.0,"0_va[14]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[3.667991302391842,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[14]","0_vm[16]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[-1.0,"0_va[16]"]},{"type":"*","args":[1.0,"0_va[14]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-1.2416585439004273,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(19, 14, 16)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c51","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[1.2416585439004273,"0_vm[16]","0_vm[16]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[16]","0_vm[14]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[16]"]},{"type":"*","args":[-1.0,"0_va[14]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[3.667991302391842,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[16]","0_vm[14]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[1.0,"0_va[16]"]},{"type":"*","args":[-1.0,"0_va[14]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-1.2416585439004273,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(19, 16, 14)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c52","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[3.654341302391842,"0_vm[16]","0_vm[16]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[16]","0_vm[14]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[16]"]},{"type":"*","args":[-1.0,"0_va[14]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[3.667991302391842,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[16]","0_vm[14]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[1.0,"0_va[16]"]},{"type":"*","args":[-1.0,"0_va[14]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-1.2416585439004273,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(19, 16, 14)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c53","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[3.027806843733998,"0_vm[5]","0_vm[5]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[5]","0_vm[11]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[5]"]},{"type":"*","args":[-1.0,"0_va[11]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[20.88296190751831,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[5]","0_vm[11]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[1.0,"0_va[5]"]},{"type":"*","args":[-1.0,"0_va[11]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-3.027806843733998,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(6, 5, 11)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c54","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[20.83991190751831,"0_vm[5]","0_vm[5]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[5]","0_vm[11]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[5]"]},{"type":"*","args":[-1.0,"0_va[11]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[20.88296190751831,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[5]","0_vm[11]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[1.0,"0_va[5]"]},{"type":"*","args":[-1.0,"0_va[11]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-3.027806843733998,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(6, 5, 11)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c55","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[3.027806843733998,"0_vm[11]","0_vm[11]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[11]","0_vm[5]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[5]"]},{"type":"*","args":[1.0,"0_va[11]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[20.88296190751831,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[11]","0_vm[5]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[-1.0,"0_va[5]"]},{"type":"*","args":[1.0,"0_va[11]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-3.027806843733998,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(6, 11, 5)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c56","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[20.83991190751831,"0_vm[11]","0_vm[11]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[11]","0_vm[5]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[5]"]},{"type":"*","args":[1.0,"0_va[11]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[20.88296190751831,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[11]","0_vm[5]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[-1.0,"0_va[5]"]},{"type":"*","args":[1.0,"0_va[11]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-3.027806843733998,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(6, 11, 5)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c57","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[17.788682717374634,"0_vm[9]","0_vm[9]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[9]","0_vm[10]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[9]"]},{"type":"*","args":[-1.0,"0_va[10]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[52.44594387363901,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[9]","0_vm[10]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[1.0,"0_va[9]"]},{"type":"*","args":[-1.0,"0_va[10]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-17.788682717374634,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(11, 9, 10)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c58","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[52.44499387363901,"0_vm[9]","0_vm[9]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[9]","0_vm[10]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[9]"]},{"type":"*","args":[-1.0,"0_va[10]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[52.44594387363901,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[9]","0_vm[10]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[1.0,"0_va[9]"]},{"type":"*","args":[-1.0,"0_va[10]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-17.788682717374634,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(11, 9, 10)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c59","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[17.788682717374634,"0_vm[10]","0_vm[10]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[10]","0_vm[9]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[9]"]},{"type":"*","args":[1.0,"0_va[10]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[52.44594387363901,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[10]","0_vm[9]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[-1.0,"0_va[9]"]},{"type":"*","args":[1.0,"0_va[10]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-17.788682717374634,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(11, 10, 9)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c60","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[52.44499387363901,"0_vm[10]","0_vm[10]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[10]","0_vm[9]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[9]"]},{"type":"*","args":[1.0,"0_va[10]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[52.44594387363901,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[10]","0_vm[9]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[-1.0,"0_va[9]"]},{"type":"*","args":[1.0,"0_va[10]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-17.788682717374634,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(11, 10, 9)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c61","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[0.9656776626482336,"0_vm[19]","0_vm[19]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[19]","0_vm[28]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[28]"]},{"type":"*","args":[1.0,"0_va[19]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[5.498037005409949,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[19]","0_vm[28]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[-1.0,"0_va[28]"]},{"type":"*","args":[1.0,"0_va[19]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.9656776626482336,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(31, 19, 28)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c62","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[5.487437005409949,"0_vm[19]","0_vm[19]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[19]","0_vm[28]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[28]"]},{"type":"*","args":[1.0,"0_va[19]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[5.498037005409949,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[19]","0_vm[28]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[-1.0,"0_va[28]"]},{"type":"*","args":[1.0,"0_va[19]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-0.9656776626482336,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(31, 19, 28)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c63","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[0.9656776626482336,"0_vm[28]","0_vm[28]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[28]","0_vm[19]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[28]"]},{"type":"*","args":[-1.0,"0_va[19]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[5.498037005409949,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[28]","0_vm[19]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[1.0,"0_va[28]"]},{"type":"*","args":[-1.0,"0_va[19]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.9656776626482336,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(31, 28, 19)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c64","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[5.487437005409949,"0_vm[28]","0_vm[28]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[28]","0_vm[19]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[28]"]},{"type":"*","args":[-1.0,"0_va[19]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[5.498037005409949,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[28]","0_vm[19]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[1.0,"0_va[28]"]},{"type":"*","args":[-1.0,"0_va[19]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-0.9656776626482336,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(31, 28, 19)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c65","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[2.3418494649701906,"0_vm[7]","0_vm[7]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[7]","0_vm[10]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[7]"]},{"type":"*","args":[-1.0,"0_va[10]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[6.467289330533839,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[7]","0_vm[10]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[1.0,"0_va[7]"]},{"type":"*","args":[-1.0,"0_va[10]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.3418494649701906,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(9, 7, 10)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c66","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[6.458739330533839,"0_vm[7]","0_vm[7]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[7]","0_vm[10]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[7]"]},{"type":"*","args":[-1.0,"0_va[10]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[6.467289330533839,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[7]","0_vm[10]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[1.0,"0_va[7]"]},{"type":"*","args":[-1.0,"0_va[10]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-2.3418494649701906,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(9, 7, 10)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c67","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[2.3418494649701906,"0_vm[10]","0_vm[10]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[10]","0_vm[7]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[7]"]},{"type":"*","args":[1.0,"0_va[10]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[6.467289330533839,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[10]","0_vm[7]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[-1.0,"0_va[7]"]},{"type":"*","args":[1.0,"0_va[10]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.3418494649701906,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(9, 10, 7)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c68","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[6.458739330533839,"0_vm[10]","0_vm[10]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[10]","0_vm[7]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[7]"]},{"type":"*","args":[1.0,"0_va[10]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[6.467289330533839,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[10]","0_vm[7]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[-1.0,"0_va[7]"]},{"type":"*","args":[1.0,"0_va[10]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-2.3418494649701906,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(9, 10, 7)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c69","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[1.2592269273704175,"0_vm[11]","0_vm[11]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[11]","0_vm[18]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[11]"]},{"type":"*","args":[-1.0,"0_va[18]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[8.698708713000553,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[11]","0_vm[18]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[1.0,"0_va[11]"]},{"type":"*","args":[-1.0,"0_va[18]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-1.2592269273704175,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(14, 11, 18)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c70","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[8.595708713000553,"0_vm[11]","0_vm[11]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[11]","0_vm[18]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[11]"]},{"type":"*","args":[-1.0,"0_va[18]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[8.698708713000553,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[11]","0_vm[18]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[1.0,"0_va[11]"]},{"type":"*","args":[-1.0,"0_va[18]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-1.2592269273704175,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(14, 11, 18)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c71","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[1.2592269273704175,"0_vm[18]","0_vm[18]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[18]","0_vm[11]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[11]"]},{"type":"*","args":[1.0,"0_va[18]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[8.698708713000553,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[18]","0_vm[11]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[-1.0,"0_va[11]"]},{"type":"*","args":[1.0,"0_va[18]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-1.2592269273704175,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(14, 18, 11)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c72","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[8.595708713000553,"0_vm[18]","0_vm[18]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[18]","0_vm[11]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[11]"]},{"type":"*","args":[1.0,"0_va[18]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[8.698708713000553,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[18]","0_vm[11]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[-1.0,"0_va[11]"]},{"type":"*","args":[1.0,"0_va[18]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-1.2592269273704175,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(14, 18, 11)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c73","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[2.5442206253457624,"0_vm[3]","0_vm[3]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[3]","0_vm[4]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[3]"]},{"type":"*","args":[-1.0,"0_va[4]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[17.010777436904807,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[3]","0_vm[4]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[1.0,"0_va[3]"]},{"type":"*","args":[-1.0,"0_va[4]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.5442206253457624,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(3, 3, 4)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c74","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[16.954277436904807,"0_vm[3]","0_vm[3]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[3]","0_vm[4]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[3]"]},{"type":"*","args":[-1.0,"0_va[4]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[17.010777436904807,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[3]","0_vm[4]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[1.0,"0_va[3]"]},{"type":"*","args":[-1.0,"0_va[4]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-2.5442206253457624,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(3, 3, 4)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c75","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[2.5442206253457624,"0_vm[4]","0_vm[4]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[4]","0_vm[3]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[3]"]},{"type":"*","args":[1.0,"0_va[4]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[17.010777436904807,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[4]","0_vm[3]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[-1.0,"0_va[3]"]},{"type":"*","args":[1.0,"0_va[4]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.5442206253457624,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(3, 4, 3)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c76","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[16.954277436904807,"0_vm[4]","0_vm[4]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[4]","0_vm[3]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[3]"]},{"type":"*","args":[1.0,"0_va[4]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[17.010777436904807,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[4]","0_vm[3]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[-1.0,"0_va[3]"]},{"type":"*","args":[1.0,"0_va[4]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-2.5442206253457624,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(3, 4, 3)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c77","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[0.5382017465334347,"0_vm[17]","0_vm[17]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[17]","0_vm[27]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[17]"]},{"type":"*","args":[-1.0,"0_va[27]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[1.6861921183958626,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[17]","0_vm[27]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[1.0,"0_va[17]"]},{"type":"*","args":[-1.0,"0_va[27]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.5382017465334347,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(29, 17, 27)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c78","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[1.6861921183958626,"0_vm[17]","0_vm[17]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[17]","0_vm[27]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[17]"]},{"type":"*","args":[-1.0,"0_va[27]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[1.6861921183958626,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[17]","0_vm[27]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[1.0,"0_va[17]"]},{"type":"*","args":[-1.0,"0_va[27]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-0.5382017465334347,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(29, 17, 27)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c79","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[0.5382017465334347,"0_vm[27]","0_vm[27]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[27]","0_vm[17]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[17]"]},{"type":"*","args":[1.0,"0_va[27]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[1.6861921183958626,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[27]","0_vm[17]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[-1.0,"0_va[17]"]},{"type":"*","args":[1.0,"0_va[27]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.5382017465334347,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(29, 27, 17)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c80","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[1.6861921183958626,"0_vm[27]","0_vm[27]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[27]","0_vm[17]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[17]"]},{"type":"*","args":[1.0,"0_va[27]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[1.6861921183958626,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[27]","0_vm[17]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[-1.0,"0_va[17]"]},{"type":"*","args":[1.0,"0_va[27]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-0.5382017465334347,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(29, 27, 17)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c81","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[10.614654857863137,"0_vm[6]","0_vm[6]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[6]","0_vm[7]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[6]"]},{"type":"*","args":[-1.0,"0_va[7]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[31.512256609281188,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[6]","0_vm[7]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[1.0,"0_va[6]"]},{"type":"*","args":[-1.0,"0_va[7]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-10.614654857863137,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(7, 6, 7)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c82","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[31.510656609281188,"0_vm[6]","0_vm[6]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[6]","0_vm[7]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[6]"]},{"type":"*","args":[-1.0,"0_va[7]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[31.512256609281188,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[6]","0_vm[7]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[1.0,"0_va[6]"]},{"type":"*","args":[-1.0,"0_va[7]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-10.614654857863137,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(7, 6, 7)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c83","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[10.614654857863137,"0_vm[7]","0_vm[7]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[7]","0_vm[6]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[6]"]},{"type":"*","args":[1.0,"0_va[7]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[31.512256609281188,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[7]","0_vm[6]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[-1.0,"0_va[6]"]},{"type":"*","args":[1.0,"0_va[7]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-10.614654857863137,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(7, 7, 6)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c84","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[31.510656609281188,"0_vm[7]","0_vm[7]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[7]","0_vm[6]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[6]"]},{"type":"*","args":[1.0,"0_va[7]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[31.512256609281188,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[7]","0_vm[6]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[-1.0,"0_va[6]"]},{"type":"*","args":[1.0,"0_va[7]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-10.614654857863137,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(7, 7, 6)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c85","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[4.66785040912336,"0_vm[22]","0_vm[22]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[22]","0_vm[23]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[23]"]},{"type":"*","args":[1.0,"0_va[22]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[8.939086077602251,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[22]","0_vm[23]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[-1.0,"0_va[23]"]},{"type":"*","args":[1.0,"0_va[22]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-4.66785040912336,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(25, 22, 23)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c86","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[8.938436077602251,"0_vm[22]","0_vm[22]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[22]","0_vm[23]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[23]"]},{"type":"*","args":[1.0,"0_va[22]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[8.939086077602251,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[22]","0_vm[23]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[-1.0,"0_va[23]"]},{"type":"*","args":[1.0,"0_va[22]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-4.66785040912336,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(25, 22, 23)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c87","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[4.66785040912336,"0_vm[23]","0_vm[23]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[23]","0_vm[22]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[23]"]},{"type":"*","args":[-1.0,"0_va[22]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[8.939086077602251,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[23]","0_vm[22]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[1.0,"0_va[23]"]},{"type":"*","args":[-1.0,"0_va[22]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-4.66785040912336,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(25, 23, 22)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c88","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[8.938436077602251,"0_vm[23]","0_vm[23]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[23]","0_vm[22]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[23]"]},{"type":"*","args":[-1.0,"0_va[22]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[8.939086077602251,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[23]","0_vm[22]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[1.0,"0_va[23]"]},{"type":"*","args":[-1.0,"0_va[22]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-4.66785040912336,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(25, 23, 22)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c89","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[2.434853977156145,"0_vm[4]","0_vm[4]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[4]","0_vm[5]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[5]"]},{"type":"*","args":[1.0,"0_va[4]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[16.36003009370084,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[4]","0_vm[5]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[-1.0,"0_va[5]"]},{"type":"*","args":[1.0,"0_va[4]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.434853977156145,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(4, 4, 5)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c90","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[16.30153009370084,"0_vm[4]","0_vm[4]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[4]","0_vm[5]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[5]"]},{"type":"*","args":[1.0,"0_va[4]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[16.36003009370084,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[4]","0_vm[5]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[-1.0,"0_va[5]"]},{"type":"*","args":[1.0,"0_va[4]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-2.434853977156145,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(4, 4, 5)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c91","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[2.434853977156145,"0_vm[5]","0_vm[5]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[5]","0_vm[4]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[5]"]},{"type":"*","args":[-1.0,"0_va[4]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[16.36003009370084,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[5]","0_vm[4]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[1.0,"0_va[5]"]},{"type":"*","args":[-1.0,"0_va[4]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.434853977156145,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(4, 5, 4)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c92","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[16.30153009370084,"0_vm[5]","0_vm[5]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[5]","0_vm[4]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[5]"]},{"type":"*","args":[-1.0,"0_va[4]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[16.36003009370084,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[5]","0_vm[4]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[1.0,"0_va[5]"]},{"type":"*","args":[-1.0,"0_va[4]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-2.434853977156145,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(4, 5, 4)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c93","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[0.64335500582701,"0_vm[9]","0_vm[9]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[9]","0_vm[16]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[16]"]},{"type":"*","args":[1.0,"0_va[9]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[1.8998888915041532,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[9]","0_vm[16]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[-1.0,"0_va[16]"]},{"type":"*","args":[1.0,"0_va[9]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.64335500582701,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(13, 9, 16)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c94","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[1.8735888915041532,"0_vm[9]","0_vm[9]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[9]","0_vm[16]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[16]"]},{"type":"*","args":[1.0,"0_va[9]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[1.8998888915041532,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[9]","0_vm[16]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[-1.0,"0_va[16]"]},{"type":"*","args":[1.0,"0_va[9]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-0.64335500582701,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(13, 9, 16)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c95","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[0.64335500582701,"0_vm[16]","0_vm[16]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[16]","0_vm[9]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[16]"]},{"type":"*","args":[-1.0,"0_va[9]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[1.8998888915041532,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[16]","0_vm[9]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[1.0,"0_va[16]"]},{"type":"*","args":[-1.0,"0_va[9]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.64335500582701,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(13, 16, 9)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c96","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[1.8735888915041532,"0_vm[16]","0_vm[16]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[16]","0_vm[9]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[16]"]},{"type":"*","args":[-1.0,"0_va[9]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[1.8998888915041532,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[16]","0_vm[9]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[1.0,"0_va[16]"]},{"type":"*","args":[-1.0,"0_va[9]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-0.64335500582701,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(13, 16, 9)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c97","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[2.5424832182137913,"0_vm[12]","0_vm[12]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[12]","0_vm[13]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[12]"]},{"type":"*","args":[-1.0,"0_va[13]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[7.029547007720768,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[12]","0_vm[13]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[1.0,"0_va[12]"]},{"type":"*","args":[-1.0,"0_va[13]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.5424832182137913,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(15, 12, 13)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c98","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[7.021647007720768,"0_vm[12]","0_vm[12]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[12]","0_vm[13]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[12]"]},{"type":"*","args":[-1.0,"0_va[13]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[7.029547007720768,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[12]","0_vm[13]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[1.0,"0_va[12]"]},{"type":"*","args":[-1.0,"0_va[13]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-2.5424832182137913,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(15, 12, 13)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c99","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[2.5424832182137913,"0_vm[13]","0_vm[13]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[13]","0_vm[12]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[12]"]},{"type":"*","args":[1.0,"0_va[13]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[7.029547007720768,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[13]","0_vm[12]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[-1.0,"0_va[12]"]},{"type":"*","args":[1.0,"0_va[13]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.5424832182137913,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(15, 13, 12)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c100","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[7.021647007720768,"0_vm[13]","0_vm[13]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[13]","0_vm[12]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[12]"]},{"type":"*","args":[1.0,"0_va[13]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[7.029547007720768,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[13]","0_vm[12]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[-1.0,"0_va[12]"]},{"type":"*","args":[1.0,"0_va[13]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-2.5424832182137913,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(15, 13, 12)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c101","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[1.070955528571676,"0_vm[2]","0_vm[2]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[2]","0_vm[3]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[3]"]},{"type":"*","args":[1.0,"0_va[2]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[7.165952433825185,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[2]","0_vm[3]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[-1.0,"0_va[3]"]},{"type":"*","args":[1.0,"0_va[2]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-1.070955528571676,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(2, 2, 3)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c102","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[7.031952433825185,"0_vm[2]","0_vm[2]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[2]","0_vm[3]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[3]"]},{"type":"*","args":[1.0,"0_va[2]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[7.165952433825185,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[2]","0_vm[3]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[-1.0,"0_va[3]"]},{"type":"*","args":[1.0,"0_va[2]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-1.070955528571676,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(2, 2, 3)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c103","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[1.070955528571676,"0_vm[3]","0_vm[3]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[3]","0_vm[2]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[3]"]},{"type":"*","args":[-1.0,"0_va[2]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[7.165952433825185,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[3]","0_vm[2]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[1.0,"0_va[3]"]},{"type":"*","args":[-1.0,"0_va[2]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-1.070955528571676,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(2, 3, 2)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c104","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[7.031952433825185,"0_vm[3]","0_vm[3]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[3]","0_vm[2]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[3]"]},{"type":"*","args":[-1.0,"0_va[2]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[7.165952433825185,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[3]","0_vm[2]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[1.0,"0_va[3]"]},{"type":"*","args":[-1.0,"0_va[2]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-1.070955528571676,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(2, 3, 2)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c105","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[1.4978494338705233,"0_vm[24]","0_vm[24]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[24]","0_vm[25]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[24]"]},{"type":"*","args":[-1.0,"0_va[25]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[2.868957761798156,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[24]","0_vm[25]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[1.0,"0_va[24]"]},{"type":"*","args":[-1.0,"0_va[25]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-1.4978494338705233,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(27, 24, 25)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c106","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[2.866907761798156,"0_vm[24]","0_vm[24]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[24]","0_vm[25]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[24]"]},{"type":"*","args":[-1.0,"0_va[25]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[2.868957761798156,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[24]","0_vm[25]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[1.0,"0_va[24]"]},{"type":"*","args":[-1.0,"0_va[25]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-1.4978494338705233,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(27, 24, 25)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c107","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[1.4978494338705233,"0_vm[25]","0_vm[25]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[25]","0_vm[24]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[24]"]},{"type":"*","args":[1.0,"0_va[25]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[2.868957761798156,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[25]","0_vm[24]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[-1.0,"0_va[24]"]},{"type":"*","args":[1.0,"0_va[25]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-1.4978494338705233,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(27, 25, 24)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c108","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[2.866907761798156,"0_vm[25]","0_vm[25]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[25]","0_vm[24]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[24]"]},{"type":"*","args":[1.0,"0_va[25]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[2.868957761798156,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[25]","0_vm[24]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[-1.0,"0_va[24]"]},{"type":"*","args":[1.0,"0_va[25]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-1.4978494338705233,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(27, 25, 24)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c109","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[0.26161249681590054,"0_vm[18]","0_vm[18]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[18]","0_vm[16]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[16]"]},{"type":"*","args":[1.0,"0_va[18]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[11.73125512037617,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[18]","0_vm[16]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[-1.0,"0_va[16]"]},{"type":"*","args":[1.0,"0_va[18]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.26161249681590054,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(21, 18, 16)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c110","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[11.73125512037617,"0_vm[18]","0_vm[18]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[18]","0_vm[16]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[16]"]},{"type":"*","args":[1.0,"0_va[18]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[11.73125512037617,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[18]","0_vm[16]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[-1.0,"0_va[16]"]},{"type":"*","args":[1.0,"0_va[18]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-0.26161249681590054,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(21, 18, 16)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c111","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[0.26161249681590054,"0_vm[16]","0_vm[16]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[16]","0_vm[18]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[16]"]},{"type":"*","args":[-1.0,"0_va[18]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[11.73125512037617,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[16]","0_vm[18]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[1.0,"0_va[16]"]},{"type":"*","args":[-1.0,"0_va[18]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.26161249681590054,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(21, 16, 18)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c112","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[11.73125512037617,"0_vm[16]","0_vm[16]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[16]","0_vm[18]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[16]"]},{"type":"*","args":[-1.0,"0_va[18]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[11.73125512037617,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[16]","0_vm[18]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[1.0,"0_va[16]"]},{"type":"*","args":[-1.0,"0_va[18]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-0.26161249681590054,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(21, 16, 18)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c113","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[2.9263284811715553,"0_vm[23]","0_vm[23]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[23]","0_vm[24]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[24]"]},{"type":"*","args":[1.0,"0_va[23]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[5.604798539074481,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[23]","0_vm[24]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[-1.0,"0_va[24]"]},{"type":"*","args":[1.0,"0_va[23]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.9263284811715553,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(26, 23, 24)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c114","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[5.603748539074481,"0_vm[23]","0_vm[23]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[23]","0_vm[24]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[24]"]},{"type":"*","args":[1.0,"0_va[23]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[5.604798539074481,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[23]","0_vm[24]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[-1.0,"0_va[24]"]},{"type":"*","args":[1.0,"0_va[23]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-2.9263284811715553,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(26, 23, 24)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c115","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[2.9263284811715553,"0_vm[24]","0_vm[24]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[24]","0_vm[23]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[24]"]},{"type":"*","args":[-1.0,"0_va[23]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[5.604798539074481,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[24]","0_vm[23]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[1.0,"0_va[24]"]},{"type":"*","args":[-1.0,"0_va[23]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.9263284811715553,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(26, 24, 23)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c116","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[5.603748539074481,"0_vm[24]","0_vm[24]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[24]","0_vm[23]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[24]"]},{"type":"*","args":[-1.0,"0_va[23]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[5.604798539074481,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[24]","0_vm[23]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[1.0,"0_va[24]"]},{"type":"*","args":[-1.0,"0_va[23]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-2.9263284811715553,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(26, 24, 23)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c117","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[2.450918029773461,"0_vm[8]","0_vm[8]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[8]","0_vm[9]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[8]"]},{"type":"*","args":[-1.0,"0_va[9]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[6.776372942488066,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[8]","0_vm[9]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[1.0,"0_va[8]"]},{"type":"*","args":[-1.0,"0_va[9]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.450918029773461,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(10, 8, 9)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c118","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[6.768172942488065,"0_vm[8]","0_vm[8]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[8]","0_vm[9]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[8]"]},{"type":"*","args":[-1.0,"0_va[9]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[6.776372942488066,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[8]","0_vm[9]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[1.0,"0_va[8]"]},{"type":"*","args":[-1.0,"0_va[9]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-2.450918029773461,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(10, 8, 9)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c119","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[2.450918029773461,"0_vm[9]","0_vm[9]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[9]","0_vm[8]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[8]"]},{"type":"*","args":[1.0,"0_va[9]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[6.776372942488066,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[9]","0_vm[8]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[-1.0,"0_va[8]"]},{"type":"*","args":[1.0,"0_va[9]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.450918029773461,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(10, 9, 8)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c120","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[6.768172942488065,"0_vm[9]","0_vm[9]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[9]","0_vm[8]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[8]"]},{"type":"*","args":[1.0,"0_va[9]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[6.776372942488066,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[9]","0_vm[8]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[-1.0,"0_va[8]"]},{"type":"*","args":[1.0,"0_va[9]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-2.450918029773461,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(10, 9, 8)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c121","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[0.9733135131308841,"0_vm[14]","0_vm[14]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[14]","0_vm[20]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[20]"]},{"type":"*","args":[1.0,"0_va[14]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[2.875699016068521,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[14]","0_vm[20]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[-1.0,"0_va[20]"]},{"type":"*","args":[1.0,"0_va[14]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.9733135131308841,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(18, 14, 20)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c122","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[2.8582990160685213,"0_vm[14]","0_vm[14]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[14]","0_vm[20]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[-1.0,"0_va[20]"]},{"type":"*","args":[1.0,"0_va[14]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[2.875699016068521,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[14]","0_vm[20]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[-1.0,"0_va[20]"]},{"type":"*","args":[1.0,"0_va[14]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-0.9733135131308841,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(18, 14, 20)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c123","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":20},"node_list":[{"type":"*","args":[0.9733135131308841,"0_vm[20]","0_vm[20]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[20]","0_vm[14]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[20]"]},{"type":"*","args":[-1.0,"0_va[14]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"sin","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[2.875699016068521,{"type":"node","index":9}]},{"type":"*","args":[1.0,"0_vm[20]","0_vm[14]"]},{"type":"+","args":[{"type":"node","index":11}]},{"type":"*","args":[1.0,"0_va[20]"]},{"type":"*","args":[-1.0,"0_va[14]"]},{"type":"+","args":[{"type":"node","index":13},{"type":"node","index":14}]},{"type":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.9733135131308841,{"type":"node","index":17}]},{"type":"+","args":[{"type":"node","index":2},{"type":"node","index":10},{"type":"node","index":18}]},{"type":"-","args":["0_p[(18, 20, 14)]",{"type":"node","index":19}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c124","function":{"type":"ScalarNonlinearFunction","root":{"type":"node","index":21},"node_list":[{"type":"*","args":[2.8582990160685213,"0_vm[20]","0_vm[20]"]},{"type":"+","args":[{"type":"node","index":1}]},{"type":"*","args":[1.0,"0_vm[20]","0_vm[14]"]},{"type":"+","args":[{"type":"node","index":3}]},{"type":"*","args":[1.0,"0_va[20]"]},{"type":"*","args":[-1.0,"0_va[14]"]},{"type":"+","args":[{"type":"node","index":5},{"type":"node","index":6}]},{"type":"cos","args":[{"type":"node","index":7}]},{"type":"*","args":[{"type":"node","index":4},{"type":"node","index":8}]},{"type":"*","args":[2.875699016068521,{"type":"node","index":9}]},{"type":"-","args":[{"type":"node","index":2},{"type":"node","index":10}]},{"type":"*","args":[1.0,"0_vm[20]","0_vm[14]"]},{"type":"+","args":[{"type":"node","index":12}]},{"type":"*","args":[1.0,"0_va[20]"]},{"type":"*","args":[-1.0,"0_va[14]"]},{"type":"+","args":[{"type":"node","index":14},{"type":"node","index":15}]},{"type":"sin","args":[{"type":"node","index":16}]},{"type":"*","args":[{"type":"node","index":13},{"type":"node","index":17}]},{"type":"*","args":[-0.9733135131308841,{"type":"node","index":18}]},{"type":"+","args":[{"type":"node","index":11},{"type":"node","index":19}]},{"type":"-","args":["0_q[(18, 20, 14)]",{"type":"node","index":20}]}]},"set":{"type":"EqualTo","value":0.0}},{"name":"c1_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[1]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c2_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(5, 5, 6)]"},{"coefficient":1.0,"variable":"0_p[(6, 5, 11)]"},{"coefficient":1.0,"variable":"0_p[(4, 5, 4)]"},{"coefficient":-1.0,"variable":"deficit[5]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c3_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(5, 5, 6)]"},{"coefficient":1.0,"variable":"0_q[(6, 5, 11)]"},{"coefficient":1.0,"variable":"0_q[(4, 5, 4)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c4_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(20, 16, 17)]"},{"coefficient":1.0,"variable":"0_p[(22, 16, 19)]"},{"coefficient":1.0,"variable":"0_p[(19, 16, 14)]"},{"coefficient":1.0,"variable":"0_p[(13, 16, 9)]"},{"coefficient":1.0,"variable":"0_p[(21, 16, 18)]"},{"coefficient":-1.0,"variable":"deficit[16]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.21439096103324617}},{"name":"c5_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(20, 16, 17)]"},{"coefficient":1.0,"variable":"0_q[(22, 16, 19)]"},{"coefficient":1.0,"variable":"0_q[(19, 16, 14)]"},{"coefficient":1.0,"variable":"0_q[(13, 16, 9)]"},{"coefficient":1.0,"variable":"0_q[(21, 16, 18)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.02572691532398954}},{"name":"c6_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(23, 20, 21)]"},{"coefficient":1.0,"variable":"0_p[(18, 20, 14)]"},{"coefficient":-1.0,"variable":"deficit[20]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.0015565421870758504}},{"name":"c7_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(23, 20, 21)]"},{"coefficient":1.0,"variable":"0_q[(18, 20, 14)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.00018678506244910206}},{"name":"c8_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(15, 12, 13)]"},{"coefficient":1.0,"variable":"0_p[(12, 12, 9)]"},{"coefficient":-1.0,"variable":"deficit[12]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.05738794110411041}},{"name":"c9_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(15, 12, 13)]"},{"coefficient":1.0,"variable":"0_q[(12, 12, 9)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.006886552932493249}},{"name":"c10_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(27, 24, 25)]"},{"coefficient":1.0,"variable":"0_p[(26, 24, 23)]"},{"coefficient":-1.0,"variable":"deficit[24]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.01804043447630477}},{"name":"c11_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(27, 24, 25)]"},{"coefficient":1.0,"variable":"0_q[(26, 24, 23)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.0021648521371565727}},{"name":"c12_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[28]"},{"coefficient":-1.0,"variable":"0_pg[30]"},{"coefficient":-1.0,"variable":"0_pg[29]"},{"coefficient":1.0,"variable":"0_p[(30, 28, 19)]"},{"coefficient":1.0,"variable":"0_p[(31, 28, 19)]"},{"coefficient":-1.0,"variable":"deficit[28]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c13_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_qg[28]"},{"coefficient":-1.0,"variable":"0_qg[30]"},{"coefficient":-1.0,"variable":"0_qg[29]"},{"coefficient":1.0,"variable":"0_q[(30, 28, 19)]"},{"coefficient":1.0,"variable":"0_q[(31, 28, 19)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c14_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[25]"},{"coefficient":1.0,"variable":"0_p[(10, 8, 9)]"},{"coefficient":1.0,"variable":"0_p[(8, 8, 7)]"},{"coefficient":-1.0,"variable":"deficit[8]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c15_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_qg[25]"},{"coefficient":1.0,"variable":"0_q[(10, 8, 9)]"},{"coefficient":1.0,"variable":"0_q[(8, 8, 7)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c16_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(29, 17, 27)]"},{"coefficient":1.0,"variable":"0_p[(20, 17, 16)]"},{"coefficient":-1.0,"variable":"deficit[17]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.267753330934522}},{"name":"c17_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(29, 17, 27)]"},{"coefficient":1.0,"variable":"0_q[(20, 17, 16)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.03213039971214264}},{"name":"c18_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[5]"},{"coefficient":-1.0,"variable":"0_pg[8]"},{"coefficient":-1.0,"variable":"0_pg[1]"},{"coefficient":-1.0,"variable":"0_pg[6]"},{"coefficient":-1.0,"variable":"0_pg[9]"},{"coefficient":-1.0,"variable":"0_pg[3]"},{"coefficient":-1.0,"variable":"0_pg[7]"},{"coefficient":-1.0,"variable":"0_pg[4]"},{"coefficient":-1.0,"variable":"0_pg[2]"},{"coefficient":-1.0,"variable":"0_pg[10]"},{"coefficient":1.0,"variable":"0_p[(1, 1, 2)]"},{"coefficient":-1.0,"variable":"deficit[1]"}],"constant":0.0},"set":{"type":"EqualTo","value":-1.6075543555612704}},{"name":"c19_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_qg[5]"},{"coefficient":-1.0,"variable":"0_qg[8]"},{"coefficient":-1.0,"variable":"0_qg[1]"},{"coefficient":-1.0,"variable":"0_qg[6]"},{"coefficient":-1.0,"variable":"0_qg[9]"},{"coefficient":-1.0,"variable":"0_qg[3]"},{"coefficient":-1.0,"variable":"0_qg[7]"},{"coefficient":-1.0,"variable":"0_qg[4]"},{"coefficient":-1.0,"variable":"0_qg[2]"},{"coefficient":-1.0,"variable":"0_qg[10]"},{"coefficient":1.0,"variable":"0_q[(1, 1, 2)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.19290652266735245}},{"name":"c20_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[21]"},{"coefficient":1.0,"variable":"0_p[(26, 23, 24)]"},{"coefficient":1.0,"variable":"0_p[(25, 23, 22)]"},{"coefficient":-1.0,"variable":"deficit[23]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.0004825663866386638}},{"name":"c21_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_qg[21]"},{"coefficient":1.0,"variable":"0_q[(26, 23, 24)]"},{"coefficient":1.0,"variable":"0_q[(25, 23, 22)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-5.790796639663966e-5}},{"name":"c22_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[34]"},{"coefficient":1.0,"variable":"0_p[(25, 22, 23)]"},{"coefficient":1.0,"variable":"0_p[(24, 22, 21)]"},{"coefficient":-1.0,"variable":"deficit[22]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.12074817048704867}},{"name":"c23_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_qg[34]"},{"coefficient":1.0,"variable":"0_q[(25, 22, 23)]"},{"coefficient":1.0,"variable":"0_q[(24, 22, 21)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.01448978045844584}},{"name":"c24_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[20]"},{"coefficient":-1.0,"variable":"0_pg[32]"},{"coefficient":-1.0,"variable":"0_pg[19]"},{"coefficient":-1.0,"variable":"0_pg[31]"},{"coefficient":-1.0,"variable":"0_pg[33]"},{"coefficient":1.0,"variable":"0_p[(30, 19, 28)]"},{"coefficient":1.0,"variable":"0_p[(31, 19, 28)]"},{"coefficient":1.0,"variable":"0_p[(22, 19, 16)]"},{"coefficient":-1.0,"variable":"deficit[19]"}],"constant":0.0},"set":{"type":"EqualTo","value":-1.4735118986170044}},{"name":"c25_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_qg[20]"},{"coefficient":-1.0,"variable":"0_qg[32]"},{"coefficient":-1.0,"variable":"0_qg[19]"},{"coefficient":-1.0,"variable":"0_qg[31]"},{"coefficient":-1.0,"variable":"0_qg[33]"},{"coefficient":1.0,"variable":"0_q[(30, 19, 28)]"},{"coefficient":1.0,"variable":"0_q[(31, 19, 28)]"},{"coefficient":1.0,"variable":"0_q[(22, 19, 16)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.1768214278340405}},{"name":"c26_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(7, 6, 7)]"},{"coefficient":1.0,"variable":"0_p[(5, 6, 5)]"},{"coefficient":-1.0,"variable":"deficit[6]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c27_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(7, 6, 7)]"},{"coefficient":1.0,"variable":"0_q[(5, 6, 5)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c28_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(14, 11, 18)]"},{"coefficient":1.0,"variable":"0_p[(6, 11, 5)]"},{"coefficient":-1.0,"variable":"deficit[11]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c29_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(14, 11, 18)]"},{"coefficient":1.0,"variable":"0_q[(6, 11, 5)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c30_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[16]"},{"coefficient":-1.0,"variable":"0_pg[17]"},{"coefficient":-1.0,"variable":"0_pg[15]"},{"coefficient":-1.0,"variable":"0_pg[18]"},{"coefficient":1.0,"variable":"0_p[(12, 9, 12)]"},{"coefficient":1.0,"variable":"0_p[(11, 9, 10)]"},{"coefficient":1.0,"variable":"0_p[(13, 9, 16)]"},{"coefficient":1.0,"variable":"0_p[(10, 9, 8)]"},{"coefficient":-1.0,"variable":"deficit[9]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.21593913974111698}},{"name":"c31_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_qg[16]"},{"coefficient":-1.0,"variable":"0_qg[17]"},{"coefficient":-1.0,"variable":"0_qg[15]"},{"coefficient":-1.0,"variable":"0_qg[18]"},{"coefficient":1.0,"variable":"0_q[(12, 9, 12)]"},{"coefficient":1.0,"variable":"0_q[(11, 9, 10)]"},{"coefficient":1.0,"variable":"0_q[(13, 9, 16)]"},{"coefficient":1.0,"variable":"0_q[(10, 9, 8)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.025912696768934037}},{"name":"c32_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(17, 14, 15)]"},{"coefficient":1.0,"variable":"0_p[(19, 14, 16)]"},{"coefficient":1.0,"variable":"0_p[(18, 14, 20)]"},{"coefficient":1.0,"variable":"0_p[(16, 14, 13)]"},{"coefficient":-1.0,"variable":"deficit[14]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c33_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(17, 14, 15)]"},{"coefficient":1.0,"variable":"0_q[(19, 14, 16)]"},{"coefficient":1.0,"variable":"0_q[(18, 14, 20)]"},{"coefficient":1.0,"variable":"0_q[(16, 14, 13)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c34_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[12]"},{"coefficient":-1.0,"variable":"0_pg[11]"},{"coefficient":-1.0,"variable":"0_pg[14]"},{"coefficient":-1.0,"variable":"0_pg[13]"},{"coefficient":1.0,"variable":"0_p[(3, 3, 4)]"},{"coefficient":1.0,"variable":"0_p[(2, 3, 2)]"},{"coefficient":-1.0,"variable":"deficit[3]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c35_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_qg[12]"},{"coefficient":-1.0,"variable":"0_qg[11]"},{"coefficient":-1.0,"variable":"0_qg[14]"},{"coefficient":-1.0,"variable":"0_qg[13]"},{"coefficient":1.0,"variable":"0_q[(3, 3, 4)]"},{"coefficient":1.0,"variable":"0_q[(2, 3, 2)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c36_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[24]"},{"coefficient":1.0,"variable":"0_p[(8, 7, 8)]"},{"coefficient":1.0,"variable":"0_p[(9, 7, 10)]"},{"coefficient":1.0,"variable":"0_p[(7, 7, 6)]"},{"coefficient":-1.0,"variable":"deficit[7]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c37_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_qg[24]"},{"coefficient":1.0,"variable":"0_q[(8, 7, 8)]"},{"coefficient":1.0,"variable":"0_q[(9, 7, 10)]"},{"coefficient":1.0,"variable":"0_q[(7, 7, 6)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c38_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(28, 25, 26)]"},{"coefficient":1.0,"variable":"0_p[(27, 25, 24)]"},{"coefficient":-1.0,"variable":"deficit[25]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.0004825663866386638}},{"name":"c39_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(28, 25, 26)]"},{"coefficient":1.0,"variable":"0_q[(27, 25, 24)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-5.790796639663966e-5}},{"name":"c40_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(4, 4, 5)]"},{"coefficient":1.0,"variable":"0_p[(3, 4, 3)]"},{"coefficient":-1.0,"variable":"deficit[4]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.02040724338005229}},{"name":"c41_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(4, 4, 5)]"},{"coefficient":1.0,"variable":"0_q[(3, 4, 3)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.002448869205606275}},{"name":"c42_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(16, 13, 14)]"},{"coefficient":1.0,"variable":"0_p[(15, 13, 12)]"},{"coefficient":-1.0,"variable":"deficit[13]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.0004825663866386638}},{"name":"c43_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(16, 13, 14)]"},{"coefficient":1.0,"variable":"0_q[(15, 13, 12)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-5.790796639663966e-5}},{"name":"c44_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(17, 15, 14)]"},{"coefficient":-1.0,"variable":"deficit[15]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.10015864047547611}},{"name":"c45_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(17, 15, 14)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.012019036857057132}},{"name":"c46_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(1, 2, 1)]"},{"coefficient":1.0,"variable":"0_p[(2, 2, 3)]"},{"coefficient":-1.0,"variable":"deficit[2]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c47_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(1, 2, 1)]"},{"coefficient":1.0,"variable":"0_q[(2, 2, 3)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c48_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[27]"},{"coefficient":1.0,"variable":"0_p[(29, 27, 17)]"},{"coefficient":-1.0,"variable":"deficit[27]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c49_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_qg[27]"},{"coefficient":1.0,"variable":"0_q[(29, 27, 17)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c50_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(24, 21, 22)]"},{"coefficient":1.0,"variable":"0_p[(23, 21, 20)]"},{"coefficient":-1.0,"variable":"deficit[21]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c51_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(24, 21, 22)]"},{"coefficient":1.0,"variable":"0_q[(23, 21, 20)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c52_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[23]"},{"coefficient":-1.0,"variable":"0_pg[22]"},{"coefficient":1.0,"variable":"0_p[(28, 26, 25)]"},{"coefficient":-1.0,"variable":"deficit[26]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.1700922829782978}},{"name":"c53_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_qg[23]"},{"coefficient":-1.0,"variable":"0_qg[22]"},{"coefficient":1.0,"variable":"0_q[(28, 26, 25)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.020411073957395734}},{"name":"c54_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[26]"},{"coefficient":1.0,"variable":"0_p[(11, 10, 9)]"},{"coefficient":1.0,"variable":"0_p[(9, 10, 7)]"},{"coefficient":-1.0,"variable":"deficit[10]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.5563327884359863}},{"name":"c55_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_qg[26]"},{"coefficient":1.0,"variable":"0_q[(11, 10, 9)]"},{"coefficient":1.0,"variable":"0_q[(9, 10, 7)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.06675993461231836}},{"name":"c56_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(21, 18, 16)]"},{"coefficient":1.0,"variable":"0_p[(14, 18, 11)]"},{"coefficient":-1.0,"variable":"deficit[18]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c57_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(21, 18, 16)]"},{"coefficient":1.0,"variable":"0_q[(14, 18, 11)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[1]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[1]_in"},{"coefficient":1.0,"variable":"reservoir[1]_out"},{"coefficient":0.6048,"variable":"outflow[1]"},{"coefficient":-0.6048,"variable":"outflow[2]"},{"coefficient":1.0,"variable":"spill[1]"},{"coefficient":-0.6048,"variable":"inflow[1]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[2]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[2]_in"},{"coefficient":1.0,"variable":"reservoir[2]_out"},{"coefficient":0.6048,"variable":"outflow[2]"},{"coefficient":1.0,"variable":"spill[2]"},{"coefficient":-0.6048,"variable":"inflow[2]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[3]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[3]_in"},{"coefficient":1.0,"variable":"reservoir[3]_out"},{"coefficient":0.6048,"variable":"outflow[3]"},{"coefficient":1.0,"variable":"spill[3]"},{"coefficient":-0.6048,"variable":"inflow[3]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[4]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[4]_in"},{"coefficient":1.0,"variable":"reservoir[4]_out"},{"coefficient":0.6048,"variable":"outflow[4]"},{"coefficient":1.0,"variable":"spill[4]"},{"coefficient":-0.6048,"variable":"inflow[4]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[5]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[5]_in"},{"coefficient":1.0,"variable":"reservoir[5]_out"},{"coefficient":0.6048,"variable":"outflow[5]"},{"coefficient":1.0,"variable":"spill[5]"},{"coefficient":-0.6048,"variable":"inflow[5]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[6]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[6]_in"},{"coefficient":1.0,"variable":"reservoir[6]_out"},{"coefficient":-0.6048,"variable":"outflow[5]"},{"coefficient":0.6048,"variable":"outflow[6]"},{"coefficient":-1.0,"variable":"spill[5]"},{"coefficient":1.0,"variable":"spill[6]"},{"coefficient":-0.6048,"variable":"inflow[6]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[7]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[7]_in"},{"coefficient":1.0,"variable":"reservoir[7]_out"},{"coefficient":0.6048,"variable":"outflow[7]"},{"coefficient":1.0,"variable":"spill[7]"},{"coefficient":-0.6048,"variable":"inflow[7]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[8]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[8]_in"},{"coefficient":1.0,"variable":"reservoir[8]_out"},{"coefficient":0.6048,"variable":"outflow[8]"},{"coefficient":1.0,"variable":"spill[8]"},{"coefficient":-0.6048,"variable":"inflow[8]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[9]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[9]_in"},{"coefficient":1.0,"variable":"reservoir[9]_out"},{"coefficient":-0.6048,"variable":"outflow[8]"},{"coefficient":0.6048,"variable":"outflow[9]"},{"coefficient":-1.0,"variable":"spill[8]"},{"coefficient":1.0,"variable":"spill[9]"},{"coefficient":-0.6048,"variable":"inflow[9]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[10]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[10]_in"},{"coefficient":1.0,"variable":"reservoir[10]_out"},{"coefficient":0.6048,"variable":"outflow[10]"},{"coefficient":1.0,"variable":"spill[10]"},{"coefficient":-0.6048,"variable":"inflow[10]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[11]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[11]_in"},{"coefficient":1.0,"variable":"reservoir[11]_out"},{"coefficient":0.6048,"variable":"outflow[11]"},{"coefficient":1.0,"variable":"spill[11]"},{"coefficient":-0.6048,"variable":"inflow[11]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[1]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[24]"},{"coefficient":-6.9953,"variable":"outflow[1]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[2]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[25]"},{"coefficient":-5.117,"variable":"outflow[2]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[3]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[26]"},{"coefficient":-9.677,"variable":"outflow[3]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[4]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[27]"},{"coefficient":-5.06,"variable":"outflow[4]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[5]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[28]"},{"coefficient":-8.11,"variable":"outflow[5]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[6]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[29]"},{"coefficient":-6.35,"variable":"outflow[6]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[7]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[30]"},{"coefficient":-3.2,"variable":"outflow[7]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[8]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[31]"},{"coefficient":-4.81,"variable":"outflow[8]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[9]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[32]"},{"coefficient":-4.47,"variable":"outflow[9]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[10]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[33]"},{"coefficient":-1.2,"variable":"outflow[10]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[11]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[34]"},{"coefficient":-2.5,"variable":"outflow[11]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"min_volume_violation_bound[1]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[1]_out"},{"coefficient":1.0,"variable":"min_volume_violation[1]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_volume_violation_bound[2]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[2]_out"},{"coefficient":1.0,"variable":"min_volume_violation[2]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_volume_violation_bound[3]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[3]_out"},{"coefficient":1.0,"variable":"min_volume_violation[3]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_volume_violation_bound[4]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[4]_out"},{"coefficient":1.0,"variable":"min_volume_violation[4]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_volume_violation_bound[5]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[5]_out"},{"coefficient":1.0,"variable":"min_volume_violation[5]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_volume_violation_bound[6]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[6]_out"},{"coefficient":1.0,"variable":"min_volume_violation[6]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_volume_violation_bound[7]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[7]_out"},{"coefficient":1.0,"variable":"min_volume_violation[7]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_volume_violation_bound[8]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[8]_out"},{"coefficient":1.0,"variable":"min_volume_violation[8]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_volume_violation_bound[9]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[9]_out"},{"coefficient":1.0,"variable":"min_volume_violation[9]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_volume_violation_bound[10]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[10]_out"},{"coefficient":1.0,"variable":"min_volume_violation[10]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_volume_violation_bound[11]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[11]_out"},{"coefficient":1.0,"variable":"min_volume_violation[11]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[1]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[1]"},{"coefficient":1.0,"variable":"min_outflow_violation[1]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[2]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[2]"},{"coefficient":1.0,"variable":"min_outflow_violation[2]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[3]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[3]"},{"coefficient":1.0,"variable":"min_outflow_violation[3]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[4]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[4]"},{"coefficient":1.0,"variable":"min_outflow_violation[4]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[5]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[5]"},{"coefficient":1.0,"variable":"min_outflow_violation[5]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[6]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[6]"},{"coefficient":1.0,"variable":"min_outflow_violation[6]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[7]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[7]"},{"coefficient":1.0,"variable":"min_outflow_violation[7]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[8]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[8]"},{"coefficient":1.0,"variable":"min_outflow_violation[8]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[9]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[9]"},{"coefficient":1.0,"variable":"min_outflow_violation[9]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[10]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[10]"},{"coefficient":1.0,"variable":"min_outflow_violation[10]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[11]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[11]"},{"coefficient":1.0,"variable":"min_outflow_violation[11]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c1_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[5]"},{"coefficient":-1.0,"variable":"0_va[6]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c2_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_va[14]"},{"coefficient":1.0,"variable":"0_va[13]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c3_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[16]"},{"coefficient":-1.0,"variable":"0_va[17]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c4_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_va[12]"},{"coefficient":1.0,"variable":"0_va[9]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c5_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_va[22]"},{"coefficient":1.0,"variable":"0_va[21]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c6_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[25]"},{"coefficient":-1.0,"variable":"0_va[26]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c7_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_va[8]"},{"coefficient":1.0,"variable":"0_va[7]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c8_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[14]"},{"coefficient":-1.0,"variable":"0_va[15]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c9_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_va[28]"},{"coefficient":1.0,"variable":"0_va[19]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c10_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_va[1]"},{"coefficient":1.0,"variable":"0_va[2]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c11_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[20]"},{"coefficient":-1.0,"variable":"0_va[21]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c12_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[16]"},{"coefficient":-1.0,"variable":"0_va[19]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c13_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_va[16]"},{"coefficient":1.0,"variable":"0_va[14]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c14_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[5]"},{"coefficient":-1.0,"variable":"0_va[11]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c15_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[9]"},{"coefficient":-1.0,"variable":"0_va[10]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c16_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[7]"},{"coefficient":-1.0,"variable":"0_va[10]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c17_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[11]"},{"coefficient":-1.0,"variable":"0_va[18]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c18_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[3]"},{"coefficient":-1.0,"variable":"0_va[4]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c19_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[17]"},{"coefficient":-1.0,"variable":"0_va[27]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c20_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[6]"},{"coefficient":-1.0,"variable":"0_va[7]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c21_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_va[23]"},{"coefficient":1.0,"variable":"0_va[22]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c22_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_va[5]"},{"coefficient":1.0,"variable":"0_va[4]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c23_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_va[16]"},{"coefficient":1.0,"variable":"0_va[9]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c24_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[12]"},{"coefficient":-1.0,"variable":"0_va[13]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c25_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_va[3]"},{"coefficient":1.0,"variable":"0_va[2]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c26_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[24]"},{"coefficient":-1.0,"variable":"0_va[25]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c27_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_va[16]"},{"coefficient":1.0,"variable":"0_va[18]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c28_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_va[24]"},{"coefficient":1.0,"variable":"0_va[23]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c29_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[8]"},{"coefficient":-1.0,"variable":"0_va[9]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c30_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_va[20]"},{"coefficient":1.0,"variable":"0_va[14]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c1_3","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(5, 5, 6)]","variable_2":"0_p[(5, 5, 6)]"},{"coefficient":2.0,"variable_1":"0_q[(5, 5, 6)]","variable_2":"0_q[(5, 5, 6)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.48999999999999994}},{"name":"c2_3","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(5, 6, 5)]","variable_2":"0_p[(5, 6, 5)]"},{"coefficient":2.0,"variable_1":"0_q[(5, 6, 5)]","variable_2":"0_q[(5, 6, 5)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.48999999999999994}},{"name":"c3_3","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(16, 13, 14)]","variable_2":"0_p[(16, 13, 14)]"},{"coefficient":2.0,"variable_1":"0_q[(16, 13, 14)]","variable_2":"0_q[(16, 13, 14)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.5476}},{"name":"c4_3","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(16, 14, 13)]","variable_2":"0_p[(16, 14, 13)]"},{"coefficient":2.0,"variable_1":"0_q[(16, 14, 13)]","variable_2":"0_q[(16, 14, 13)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.5476}},{"name":"c5_3","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(20, 16, 17)]","variable_2":"0_p[(20, 16, 17)]"},{"coefficient":2.0,"variable_1":"0_q[(20, 16, 17)]","variable_2":"0_q[(20, 16, 17)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0625}},{"name":"c6_3","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(20, 17, 16)]","variable_2":"0_p[(20, 17, 16)]"},{"coefficient":2.0,"variable_1":"0_q[(20, 17, 16)]","variable_2":"0_q[(20, 17, 16)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0625}},{"name":"c7_3","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(12, 9, 12)]","variable_2":"0_p[(12, 9, 12)]"},{"coefficient":2.0,"variable_1":"0_q[(12, 9, 12)]","variable_2":"0_q[(12, 9, 12)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.5476}},{"name":"c8_3","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(12, 12, 9)]","variable_2":"0_p[(12, 12, 9)]"},{"coefficient":2.0,"variable_1":"0_q[(12, 12, 9)]","variable_2":"0_q[(12, 12, 9)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.5476}},{"name":"c9_3","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(24, 21, 22)]","variable_2":"0_p[(24, 21, 22)]"},{"coefficient":2.0,"variable_1":"0_q[(24, 21, 22)]","variable_2":"0_q[(24, 21, 22)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0625}},{"name":"c10_3","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(24, 22, 21)]","variable_2":"0_p[(24, 22, 21)]"},{"coefficient":2.0,"variable_1":"0_q[(24, 22, 21)]","variable_2":"0_q[(24, 22, 21)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0625}},{"name":"c11_3","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(28, 25, 26)]","variable_2":"0_p[(28, 25, 26)]"},{"coefficient":2.0,"variable_1":"0_q[(28, 25, 26)]","variable_2":"0_q[(28, 25, 26)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.016900000000000002}},{"name":"c12_3","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(28, 26, 25)]","variable_2":"0_p[(28, 26, 25)]"},{"coefficient":2.0,"variable_1":"0_q[(28, 26, 25)]","variable_2":"0_q[(28, 26, 25)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.016900000000000002}},{"name":"c13_3","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(8, 7, 8)]","variable_2":"0_p[(8, 7, 8)]"},{"coefficient":2.0,"variable_1":"0_q[(8, 7, 8)]","variable_2":"0_q[(8, 7, 8)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.5476}},{"name":"c14_3","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(8, 8, 7)]","variable_2":"0_p[(8, 8, 7)]"},{"coefficient":2.0,"variable_1":"0_q[(8, 8, 7)]","variable_2":"0_q[(8, 8, 7)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.5476}},{"name":"c15_3","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(17, 14, 15)]","variable_2":"0_p[(17, 14, 15)]"},{"coefficient":2.0,"variable_1":"0_q[(17, 14, 15)]","variable_2":"0_q[(17, 14, 15)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.25}},{"name":"c16_3","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(17, 15, 14)]","variable_2":"0_p[(17, 15, 14)]"},{"coefficient":2.0,"variable_1":"0_q[(17, 15, 14)]","variable_2":"0_q[(17, 15, 14)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.25}},{"name":"c17_3","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(30, 19, 28)]","variable_2":"0_p[(30, 19, 28)]"},{"coefficient":2.0,"variable_1":"0_q[(30, 19, 28)]","variable_2":"0_q[(30, 19, 28)]"}],"constant":0.0},"set":{"type":"LessThan","upper":1.0}},{"name":"c18_3","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(30, 28, 19)]","variable_2":"0_p[(30, 28, 19)]"},{"coefficient":2.0,"variable_1":"0_q[(30, 28, 19)]","variable_2":"0_q[(30, 28, 19)]"}],"constant":0.0},"set":{"type":"LessThan","upper":1.0}},{"name":"c19_3","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(1, 2, 1)]","variable_2":"0_p[(1, 2, 1)]"},{"coefficient":2.0,"variable_1":"0_q[(1, 2, 1)]","variable_2":"0_q[(1, 2, 1)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.48999999999999994}},{"name":"c20_3","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(1, 1, 2)]","variable_2":"0_p[(1, 1, 2)]"},{"coefficient":2.0,"variable_1":"0_q[(1, 1, 2)]","variable_2":"0_q[(1, 1, 2)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.48999999999999994}},{"name":"c21_3","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(23, 20, 21)]","variable_2":"0_p[(23, 20, 21)]"},{"coefficient":2.0,"variable_1":"0_q[(23, 20, 21)]","variable_2":"0_q[(23, 20, 21)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.22089999999999999}},{"name":"c22_3","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(23, 21, 20)]","variable_2":"0_p[(23, 21, 20)]"},{"coefficient":2.0,"variable_1":"0_q[(23, 21, 20)]","variable_2":"0_q[(23, 21, 20)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.22089999999999999}},{"name":"c23_3","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(22, 16, 19)]","variable_2":"0_p[(22, 16, 19)]"},{"coefficient":2.0,"variable_1":"0_q[(22, 16, 19)]","variable_2":"0_q[(22, 16, 19)]"}],"constant":0.0},"set":{"type":"LessThan","upper":1.1236000000000002}},{"name":"c24_3","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(22, 19, 16)]","variable_2":"0_p[(22, 19, 16)]"},{"coefficient":2.0,"variable_1":"0_q[(22, 19, 16)]","variable_2":"0_q[(22, 19, 16)]"}],"constant":0.0},"set":{"type":"LessThan","upper":1.1236000000000002}},{"name":"c25_3","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(19, 14, 16)]","variable_2":"0_p[(19, 14, 16)]"},{"coefficient":2.0,"variable_1":"0_q[(19, 14, 16)]","variable_2":"0_q[(19, 14, 16)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.5476}},{"name":"c26_3","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(19, 16, 14)]","variable_2":"0_p[(19, 16, 14)]"},{"coefficient":2.0,"variable_1":"0_q[(19, 16, 14)]","variable_2":"0_q[(19, 16, 14)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.5476}},{"name":"c27_3","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(6, 5, 11)]","variable_2":"0_p[(6, 5, 11)]"},{"coefficient":2.0,"variable_1":"0_q[(6, 5, 11)]","variable_2":"0_q[(6, 5, 11)]"}],"constant":0.0},"set":{"type":"LessThan","upper":1.6900000000000002}},{"name":"c28_3","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(6, 11, 5)]","variable_2":"0_p[(6, 11, 5)]"},{"coefficient":2.0,"variable_1":"0_q[(6, 11, 5)]","variable_2":"0_q[(6, 11, 5)]"}],"constant":0.0},"set":{"type":"LessThan","upper":1.6900000000000002}},{"name":"c29_3","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(11, 9, 10)]","variable_2":"0_p[(11, 9, 10)]"},{"coefficient":2.0,"variable_1":"0_q[(11, 9, 10)]","variable_2":"0_q[(11, 9, 10)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.5476}},{"name":"c30_3","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(11, 10, 9)]","variable_2":"0_p[(11, 10, 9)]"},{"coefficient":2.0,"variable_1":"0_q[(11, 10, 9)]","variable_2":"0_q[(11, 10, 9)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.5476}},{"name":"c31_2","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(31, 19, 28)]","variable_2":"0_p[(31, 19, 28)]"},{"coefficient":2.0,"variable_1":"0_q[(31, 19, 28)]","variable_2":"0_q[(31, 19, 28)]"}],"constant":0.0},"set":{"type":"LessThan","upper":1.0}},{"name":"c32_2","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(31, 28, 19)]","variable_2":"0_p[(31, 28, 19)]"},{"coefficient":2.0,"variable_1":"0_q[(31, 28, 19)]","variable_2":"0_q[(31, 28, 19)]"}],"constant":0.0},"set":{"type":"LessThan","upper":1.0}},{"name":"c33_2","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(9, 7, 10)]","variable_2":"0_p[(9, 7, 10)]"},{"coefficient":2.0,"variable_1":"0_q[(9, 7, 10)]","variable_2":"0_q[(9, 7, 10)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.5476}},{"name":"c34_2","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(9, 10, 7)]","variable_2":"0_p[(9, 10, 7)]"},{"coefficient":2.0,"variable_1":"0_q[(9, 10, 7)]","variable_2":"0_q[(9, 10, 7)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.5476}},{"name":"c35_2","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(14, 11, 18)]","variable_2":"0_p[(14, 11, 18)]"},{"coefficient":2.0,"variable_1":"0_q[(14, 11, 18)]","variable_2":"0_q[(14, 11, 18)]"}],"constant":0.0},"set":{"type":"LessThan","upper":1.6900000000000002}},{"name":"c36_2","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(14, 18, 11)]","variable_2":"0_p[(14, 18, 11)]"},{"coefficient":2.0,"variable_1":"0_q[(14, 18, 11)]","variable_2":"0_q[(14, 18, 11)]"}],"constant":0.0},"set":{"type":"LessThan","upper":1.6900000000000002}},{"name":"c37_2","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(3, 3, 4)]","variable_2":"0_p[(3, 3, 4)]"},{"coefficient":2.0,"variable_1":"0_q[(3, 3, 4)]","variable_2":"0_q[(3, 3, 4)]"}],"constant":0.0},"set":{"type":"LessThan","upper":1.6900000000000002}},{"name":"c38_2","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(3, 4, 3)]","variable_2":"0_p[(3, 4, 3)]"},{"coefficient":2.0,"variable_1":"0_q[(3, 4, 3)]","variable_2":"0_q[(3, 4, 3)]"}],"constant":0.0},"set":{"type":"LessThan","upper":1.6900000000000002}},{"name":"c39_2","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(29, 17, 27)]","variable_2":"0_p[(29, 17, 27)]"},{"coefficient":2.0,"variable_1":"0_q[(29, 17, 27)]","variable_2":"0_q[(29, 17, 27)]"}],"constant":0.0},"set":{"type":"LessThan","upper":4.0}},{"name":"c40_2","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(29, 27, 17)]","variable_2":"0_p[(29, 27, 17)]"},{"coefficient":2.0,"variable_1":"0_q[(29, 27, 17)]","variable_2":"0_q[(29, 27, 17)]"}],"constant":0.0},"set":{"type":"LessThan","upper":4.0}},{"name":"c41_2","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(7, 6, 7)]","variable_2":"0_p[(7, 6, 7)]"},{"coefficient":2.0,"variable_1":"0_q[(7, 6, 7)]","variable_2":"0_q[(7, 6, 7)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.5476}},{"name":"c42_2","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(7, 7, 6)]","variable_2":"0_p[(7, 7, 6)]"},{"coefficient":2.0,"variable_1":"0_q[(7, 7, 6)]","variable_2":"0_q[(7, 7, 6)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.5476}},{"name":"c43_2","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(25, 22, 23)]","variable_2":"0_p[(25, 22, 23)]"},{"coefficient":2.0,"variable_1":"0_q[(25, 22, 23)]","variable_2":"0_q[(25, 22, 23)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.10890000000000001}},{"name":"c44_2","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(25, 23, 22)]","variable_2":"0_p[(25, 23, 22)]"},{"coefficient":2.0,"variable_1":"0_q[(25, 23, 22)]","variable_2":"0_q[(25, 23, 22)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.10890000000000001}},{"name":"c45_2","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(4, 4, 5)]","variable_2":"0_p[(4, 4, 5)]"},{"coefficient":2.0,"variable_1":"0_q[(4, 4, 5)]","variable_2":"0_q[(4, 4, 5)]"}],"constant":0.0},"set":{"type":"LessThan","upper":1.6900000000000002}},{"name":"c46_2","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(4, 5, 4)]","variable_2":"0_p[(4, 5, 4)]"},{"coefficient":2.0,"variable_1":"0_q[(4, 5, 4)]","variable_2":"0_q[(4, 5, 4)]"}],"constant":0.0},"set":{"type":"LessThan","upper":1.6900000000000002}},{"name":"c47_2","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(13, 9, 16)]","variable_2":"0_p[(13, 9, 16)]"},{"coefficient":2.0,"variable_1":"0_q[(13, 9, 16)]","variable_2":"0_q[(13, 9, 16)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.5476}},{"name":"c48_2","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(13, 16, 9)]","variable_2":"0_p[(13, 16, 9)]"},{"coefficient":2.0,"variable_1":"0_q[(13, 16, 9)]","variable_2":"0_q[(13, 16, 9)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.5476}},{"name":"c49_2","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(15, 12, 13)]","variable_2":"0_p[(15, 12, 13)]"},{"coefficient":2.0,"variable_1":"0_q[(15, 12, 13)]","variable_2":"0_q[(15, 12, 13)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.5476}},{"name":"c50_2","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(15, 13, 12)]","variable_2":"0_p[(15, 13, 12)]"},{"coefficient":2.0,"variable_1":"0_q[(15, 13, 12)]","variable_2":"0_q[(15, 13, 12)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.5476}},{"name":"c51_2","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(2, 2, 3)]","variable_2":"0_p[(2, 2, 3)]"},{"coefficient":2.0,"variable_1":"0_q[(2, 2, 3)]","variable_2":"0_q[(2, 2, 3)]"}],"constant":0.0},"set":{"type":"LessThan","upper":1.6900000000000002}},{"name":"c52_2","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(2, 3, 2)]","variable_2":"0_p[(2, 3, 2)]"},{"coefficient":2.0,"variable_1":"0_q[(2, 3, 2)]","variable_2":"0_q[(2, 3, 2)]"}],"constant":0.0},"set":{"type":"LessThan","upper":1.6900000000000002}},{"name":"c53_2","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(27, 24, 25)]","variable_2":"0_p[(27, 24, 25)]"},{"coefficient":2.0,"variable_1":"0_q[(27, 24, 25)]","variable_2":"0_q[(27, 24, 25)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.016900000000000002}},{"name":"c54_2","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(27, 25, 24)]","variable_2":"0_p[(27, 25, 24)]"},{"coefficient":2.0,"variable_1":"0_q[(27, 25, 24)]","variable_2":"0_q[(27, 25, 24)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.016900000000000002}},{"name":"c55_2","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(21, 18, 16)]","variable_2":"0_p[(21, 18, 16)]"},{"coefficient":2.0,"variable_1":"0_q[(21, 18, 16)]","variable_2":"0_q[(21, 18, 16)]"}],"constant":0.0},"set":{"type":"LessThan","upper":1.0}},{"name":"c56_2","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(21, 16, 18)]","variable_2":"0_p[(21, 16, 18)]"},{"coefficient":2.0,"variable_1":"0_q[(21, 16, 18)]","variable_2":"0_q[(21, 16, 18)]"}],"constant":0.0},"set":{"type":"LessThan","upper":1.0}},{"name":"c57_2","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(26, 23, 24)]","variable_2":"0_p[(26, 23, 24)]"},{"coefficient":2.0,"variable_1":"0_q[(26, 23, 24)]","variable_2":"0_q[(26, 23, 24)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.016900000000000002}},{"name":"c58_1","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(26, 24, 23)]","variable_2":"0_p[(26, 24, 23)]"},{"coefficient":2.0,"variable_1":"0_q[(26, 24, 23)]","variable_2":"0_q[(26, 24, 23)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.016900000000000002}},{"name":"c59_1","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(10, 8, 9)]","variable_2":"0_p[(10, 8, 9)]"},{"coefficient":2.0,"variable_1":"0_q[(10, 8, 9)]","variable_2":"0_q[(10, 8, 9)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.5476}},{"name":"c60_1","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(10, 9, 8)]","variable_2":"0_p[(10, 9, 8)]"},{"coefficient":2.0,"variable_1":"0_q[(10, 9, 8)]","variable_2":"0_q[(10, 9, 8)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.5476}},{"name":"c61_1","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(18, 14, 20)]","variable_2":"0_p[(18, 14, 20)]"},{"coefficient":2.0,"variable_1":"0_q[(18, 14, 20)]","variable_2":"0_q[(18, 14, 20)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.22089999999999999}},{"name":"c62_1","function":{"type":"ScalarQuadraticFunction","affine_terms":[],"quadratic_terms":[{"coefficient":2.0,"variable_1":"0_p[(18, 20, 14)]","variable_2":"0_p[(18, 20, 14)]"},{"coefficient":2.0,"variable_1":"0_q[(18, 20, 14)]","variable_2":"0_q[(18, 20, 14)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.22089999999999999}},{"function":{"type":"Variable","name":"reservoir[1]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"reservoir[2]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"reservoir[3]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"reservoir[4]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"reservoir[5]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"reservoir[6]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"reservoir[7]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"reservoir[8]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"reservoir[9]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"reservoir[10]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"reservoir[11]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"inflow[1]"},"set":{"type":"EqualTo","value":1.054227917226262}},{"function":{"type":"Variable","name":"inflow[2]"},"set":{"type":"EqualTo","value":15.253237155042374}},{"function":{"type":"Variable","name":"inflow[3]"},"set":{"type":"EqualTo","value":0.42297175432264633}},{"function":{"type":"Variable","name":"inflow[4]"},"set":{"type":"EqualTo","value":4.444426961132509}},{"function":{"type":"Variable","name":"inflow[5]"},"set":{"type":"EqualTo","value":5.401448346338854}},{"function":{"type":"Variable","name":"inflow[6]"},"set":{"type":"EqualTo","value":7.602365317441269}},{"function":{"type":"Variable","name":"inflow[7]"},"set":{"type":"EqualTo","value":0.40433946449534874}},{"function":{"type":"Variable","name":"inflow[8]"},"set":{"type":"EqualTo","value":10.01360814824206}},{"function":{"type":"Variable","name":"inflow[9]"},"set":{"type":"EqualTo","value":8.080938535198477}},{"function":{"type":"Variable","name":"inflow[10]"},"set":{"type":"EqualTo","value":1.0239458291153407}},{"function":{"type":"Variable","name":"inflow[11]"},"set":{"type":"EqualTo","value":3.507487794885554}},{"function":{"type":"Variable","name":"0_vm[5]"},"set":{"type":"GreaterThan","lower":0.9}},{"function":{"type":"Variable","name":"0_vm[16]"},"set":{"type":"GreaterThan","lower":0.9}},{"function":{"type":"Variable","name":"0_vm[20]"},"set":{"type":"GreaterThan","lower":0.9}},{"function":{"type":"Variable","name":"0_vm[12]"},"set":{"type":"GreaterThan","lower":0.9}},{"function":{"type":"Variable","name":"0_vm[24]"},"set":{"type":"GreaterThan","lower":0.9}},{"function":{"type":"Variable","name":"0_vm[28]"},"set":{"type":"GreaterThan","lower":0.9}},{"function":{"type":"Variable","name":"0_vm[8]"},"set":{"type":"GreaterThan","lower":0.9}},{"function":{"type":"Variable","name":"0_vm[17]"},"set":{"type":"GreaterThan","lower":0.9}},{"function":{"type":"Variable","name":"0_vm[1]"},"set":{"type":"GreaterThan","lower":0.9}},{"function":{"type":"Variable","name":"0_vm[23]"},"set":{"type":"GreaterThan","lower":0.9}},{"function":{"type":"Variable","name":"0_vm[22]"},"set":{"type":"GreaterThan","lower":0.9}},{"function":{"type":"Variable","name":"0_vm[19]"},"set":{"type":"GreaterThan","lower":0.9}},{"function":{"type":"Variable","name":"0_vm[6]"},"set":{"type":"GreaterThan","lower":0.9}},{"function":{"type":"Variable","name":"0_vm[11]"},"set":{"type":"GreaterThan","lower":0.9}},{"function":{"type":"Variable","name":"0_vm[9]"},"set":{"type":"GreaterThan","lower":0.9}},{"function":{"type":"Variable","name":"0_vm[14]"},"set":{"type":"GreaterThan","lower":0.9}},{"function":{"type":"Variable","name":"0_vm[3]"},"set":{"type":"GreaterThan","lower":0.9}},{"function":{"type":"Variable","name":"0_vm[7]"},"set":{"type":"GreaterThan","lower":0.9}},{"function":{"type":"Variable","name":"0_vm[25]"},"set":{"type":"GreaterThan","lower":0.9}},{"function":{"type":"Variable","name":"0_vm[4]"},"set":{"type":"GreaterThan","lower":0.9}},{"function":{"type":"Variable","name":"0_vm[13]"},"set":{"type":"GreaterThan","lower":0.9}},{"function":{"type":"Variable","name":"0_vm[15]"},"set":{"type":"GreaterThan","lower":0.9}},{"function":{"type":"Variable","name":"0_vm[2]"},"set":{"type":"GreaterThan","lower":0.9}},{"function":{"type":"Variable","name":"0_vm[27]"},"set":{"type":"GreaterThan","lower":0.9}},{"function":{"type":"Variable","name":"0_vm[21]"},"set":{"type":"GreaterThan","lower":0.9}},{"function":{"type":"Variable","name":"0_vm[26]"},"set":{"type":"GreaterThan","lower":0.9}},{"function":{"type":"Variable","name":"0_vm[10]"},"set":{"type":"GreaterThan","lower":0.9}},{"function":{"type":"Variable","name":"0_vm[18]"},"set":{"type":"GreaterThan","lower":0.9}},{"function":{"type":"Variable","name":"0_pg[5]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[16]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[20]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[12]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[24]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[28]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[8]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[17]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[30]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[1]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[23]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[32]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[22]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[6]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[19]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[11]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[31]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[9]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[14]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[3]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[29]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[33]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[25]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[7]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[34]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[4]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[13]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[15]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[2]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[27]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[21]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[26]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[10]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[18]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_qg[5]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[16]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[20]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[12]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[24]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[28]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[8]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[17]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[30]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[1]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[23]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[32]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[22]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[6]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[19]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[11]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[31]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[9]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[14]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[3]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[29]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[33]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[25]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[7]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[34]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[4]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[13]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[15]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[2]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[27]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[21]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[26]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[10]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[18]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_p[(5, 5, 6)]"},"set":{"type":"GreaterThan","lower":-0.7}},{"function":{"type":"Variable","name":"0_p[(16, 13, 14)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(20, 16, 17)]"},"set":{"type":"GreaterThan","lower":-0.25}},{"function":{"type":"Variable","name":"0_p[(12, 9, 12)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(24, 21, 22)]"},"set":{"type":"GreaterThan","lower":-0.25}},{"function":{"type":"Variable","name":"0_p[(28, 25, 26)]"},"set":{"type":"GreaterThan","lower":-0.13}},{"function":{"type":"Variable","name":"0_p[(8, 7, 8)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(17, 14, 15)]"},"set":{"type":"GreaterThan","lower":-0.5}},{"function":{"type":"Variable","name":"0_p[(30, 19, 28)]"},"set":{"type":"GreaterThan","lower":-1.0}},{"function":{"type":"Variable","name":"0_p[(1, 2, 1)]"},"set":{"type":"GreaterThan","lower":-0.7}},{"function":{"type":"Variable","name":"0_p[(23, 20, 21)]"},"set":{"type":"GreaterThan","lower":-0.47}},{"function":{"type":"Variable","name":"0_p[(22, 16, 19)]"},"set":{"type":"GreaterThan","lower":-1.06}},{"function":{"type":"Variable","name":"0_p[(19, 14, 16)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(6, 5, 11)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_p[(11, 9, 10)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(31, 19, 28)]"},"set":{"type":"GreaterThan","lower":-1.0}},{"function":{"type":"Variable","name":"0_p[(9, 7, 10)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(14, 11, 18)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_p[(3, 3, 4)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_p[(29, 17, 27)]"},"set":{"type":"GreaterThan","lower":-2.0}},{"function":{"type":"Variable","name":"0_p[(7, 6, 7)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(25, 22, 23)]"},"set":{"type":"GreaterThan","lower":-0.33}},{"function":{"type":"Variable","name":"0_p[(4, 4, 5)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_p[(13, 9, 16)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(15, 12, 13)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(2, 2, 3)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_p[(27, 24, 25)]"},"set":{"type":"GreaterThan","lower":-0.13}},{"function":{"type":"Variable","name":"0_p[(21, 18, 16)]"},"set":{"type":"GreaterThan","lower":-1.0}},{"function":{"type":"Variable","name":"0_p[(26, 23, 24)]"},"set":{"type":"GreaterThan","lower":-0.13}},{"function":{"type":"Variable","name":"0_p[(10, 8, 9)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(18, 14, 20)]"},"set":{"type":"GreaterThan","lower":-0.47}},{"function":{"type":"Variable","name":"0_p[(5, 6, 5)]"},"set":{"type":"GreaterThan","lower":-0.7}},{"function":{"type":"Variable","name":"0_p[(16, 14, 13)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(20, 17, 16)]"},"set":{"type":"GreaterThan","lower":-0.25}},{"function":{"type":"Variable","name":"0_p[(12, 12, 9)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(24, 22, 21)]"},"set":{"type":"GreaterThan","lower":-0.25}},{"function":{"type":"Variable","name":"0_p[(28, 26, 25)]"},"set":{"type":"GreaterThan","lower":-0.13}},{"function":{"type":"Variable","name":"0_p[(8, 8, 7)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(17, 15, 14)]"},"set":{"type":"GreaterThan","lower":-0.5}},{"function":{"type":"Variable","name":"0_p[(30, 28, 19)]"},"set":{"type":"GreaterThan","lower":-1.0}},{"function":{"type":"Variable","name":"0_p[(1, 1, 2)]"},"set":{"type":"GreaterThan","lower":-0.7}},{"function":{"type":"Variable","name":"0_p[(23, 21, 20)]"},"set":{"type":"GreaterThan","lower":-0.47}},{"function":{"type":"Variable","name":"0_p[(22, 19, 16)]"},"set":{"type":"GreaterThan","lower":-1.06}},{"function":{"type":"Variable","name":"0_p[(19, 16, 14)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(6, 11, 5)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_p[(11, 10, 9)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(31, 28, 19)]"},"set":{"type":"GreaterThan","lower":-1.0}},{"function":{"type":"Variable","name":"0_p[(9, 10, 7)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(14, 18, 11)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_p[(3, 4, 3)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_p[(29, 27, 17)]"},"set":{"type":"GreaterThan","lower":-2.0}},{"function":{"type":"Variable","name":"0_p[(7, 7, 6)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(25, 23, 22)]"},"set":{"type":"GreaterThan","lower":-0.33}},{"function":{"type":"Variable","name":"0_p[(4, 5, 4)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_p[(13, 16, 9)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(15, 13, 12)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(2, 3, 2)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_p[(27, 25, 24)]"},"set":{"type":"GreaterThan","lower":-0.13}},{"function":{"type":"Variable","name":"0_p[(21, 16, 18)]"},"set":{"type":"GreaterThan","lower":-1.0}},{"function":{"type":"Variable","name":"0_p[(26, 24, 23)]"},"set":{"type":"GreaterThan","lower":-0.13}},{"function":{"type":"Variable","name":"0_p[(10, 9, 8)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(18, 20, 14)]"},"set":{"type":"GreaterThan","lower":-0.47}},{"function":{"type":"Variable","name":"0_q[(5, 5, 6)]"},"set":{"type":"GreaterThan","lower":-0.7}},{"function":{"type":"Variable","name":"0_q[(16, 13, 14)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(20, 16, 17)]"},"set":{"type":"GreaterThan","lower":-0.25}},{"function":{"type":"Variable","name":"0_q[(12, 9, 12)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(24, 21, 22)]"},"set":{"type":"GreaterThan","lower":-0.25}},{"function":{"type":"Variable","name":"0_q[(28, 25, 26)]"},"set":{"type":"GreaterThan","lower":-0.13}},{"function":{"type":"Variable","name":"0_q[(8, 7, 8)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(17, 14, 15)]"},"set":{"type":"GreaterThan","lower":-0.5}},{"function":{"type":"Variable","name":"0_q[(30, 19, 28)]"},"set":{"type":"GreaterThan","lower":-1.0}},{"function":{"type":"Variable","name":"0_q[(1, 2, 1)]"},"set":{"type":"GreaterThan","lower":-0.7}},{"function":{"type":"Variable","name":"0_q[(23, 20, 21)]"},"set":{"type":"GreaterThan","lower":-0.47}},{"function":{"type":"Variable","name":"0_q[(22, 16, 19)]"},"set":{"type":"GreaterThan","lower":-1.06}},{"function":{"type":"Variable","name":"0_q[(19, 14, 16)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(6, 5, 11)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_q[(11, 9, 10)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(31, 19, 28)]"},"set":{"type":"GreaterThan","lower":-1.0}},{"function":{"type":"Variable","name":"0_q[(9, 7, 10)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(14, 11, 18)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_q[(3, 3, 4)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_q[(29, 17, 27)]"},"set":{"type":"GreaterThan","lower":-2.0}},{"function":{"type":"Variable","name":"0_q[(7, 6, 7)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(25, 22, 23)]"},"set":{"type":"GreaterThan","lower":-0.33}},{"function":{"type":"Variable","name":"0_q[(4, 4, 5)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_q[(13, 9, 16)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(15, 12, 13)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(2, 2, 3)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_q[(27, 24, 25)]"},"set":{"type":"GreaterThan","lower":-0.13}},{"function":{"type":"Variable","name":"0_q[(21, 18, 16)]"},"set":{"type":"GreaterThan","lower":-1.0}},{"function":{"type":"Variable","name":"0_q[(26, 23, 24)]"},"set":{"type":"GreaterThan","lower":-0.13}},{"function":{"type":"Variable","name":"0_q[(10, 8, 9)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(18, 14, 20)]"},"set":{"type":"GreaterThan","lower":-0.47}},{"function":{"type":"Variable","name":"0_q[(5, 6, 5)]"},"set":{"type":"GreaterThan","lower":-0.7}},{"function":{"type":"Variable","name":"0_q[(16, 14, 13)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(20, 17, 16)]"},"set":{"type":"GreaterThan","lower":-0.25}},{"function":{"type":"Variable","name":"0_q[(12, 12, 9)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(24, 22, 21)]"},"set":{"type":"GreaterThan","lower":-0.25}},{"function":{"type":"Variable","name":"0_q[(28, 26, 25)]"},"set":{"type":"GreaterThan","lower":-0.13}},{"function":{"type":"Variable","name":"0_q[(8, 8, 7)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(17, 15, 14)]"},"set":{"type":"GreaterThan","lower":-0.5}},{"function":{"type":"Variable","name":"0_q[(30, 28, 19)]"},"set":{"type":"GreaterThan","lower":-1.0}},{"function":{"type":"Variable","name":"0_q[(1, 1, 2)]"},"set":{"type":"GreaterThan","lower":-0.7}},{"function":{"type":"Variable","name":"0_q[(23, 21, 20)]"},"set":{"type":"GreaterThan","lower":-0.47}},{"function":{"type":"Variable","name":"0_q[(22, 19, 16)]"},"set":{"type":"GreaterThan","lower":-1.06}},{"function":{"type":"Variable","name":"0_q[(19, 16, 14)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(6, 11, 5)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_q[(11, 10, 9)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(31, 28, 19)]"},"set":{"type":"GreaterThan","lower":-1.0}},{"function":{"type":"Variable","name":"0_q[(9, 10, 7)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(14, 18, 11)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_q[(3, 4, 3)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_q[(29, 27, 17)]"},"set":{"type":"GreaterThan","lower":-2.0}},{"function":{"type":"Variable","name":"0_q[(7, 7, 6)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(25, 23, 22)]"},"set":{"type":"GreaterThan","lower":-0.33}},{"function":{"type":"Variable","name":"0_q[(4, 5, 4)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_q[(13, 16, 9)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(15, 13, 12)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(2, 3, 2)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_q[(27, 25, 24)]"},"set":{"type":"GreaterThan","lower":-0.13}},{"function":{"type":"Variable","name":"0_q[(21, 16, 18)]"},"set":{"type":"GreaterThan","lower":-1.0}},{"function":{"type":"Variable","name":"0_q[(26, 24, 23)]"},"set":{"type":"GreaterThan","lower":-0.13}},{"function":{"type":"Variable","name":"0_q[(10, 9, 8)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(18, 20, 14)]"},"set":{"type":"GreaterThan","lower":-0.47}},{"function":{"type":"Variable","name":"reservoir[1]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"reservoir[2]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"reservoir[3]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"reservoir[4]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"reservoir[5]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"reservoir[6]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"reservoir[7]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"reservoir[8]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"reservoir[9]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"reservoir[10]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"reservoir[11]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[1]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[2]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[3]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[4]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[5]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[6]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[7]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[8]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[9]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[10]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[11]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[1]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[2]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[3]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[4]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[5]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[6]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[7]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[8]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[9]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[10]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[11]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[1]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[2]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[3]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[4]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[5]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[6]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[7]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[8]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[9]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[10]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[11]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[1]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[2]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[3]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[4]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[5]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[6]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[7]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[8]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[9]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[10]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[11]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[1]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[2]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[3]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[4]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[5]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[6]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[7]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[8]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[9]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[10]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[11]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[12]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[13]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[14]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[15]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[16]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[17]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[18]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[19]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[20]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[21]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[22]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[23]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[24]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[25]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[26]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[27]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[28]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_vm[5]"},"set":{"type":"LessThan","upper":1.1}},{"function":{"type":"Variable","name":"0_vm[16]"},"set":{"type":"LessThan","upper":1.1}},{"function":{"type":"Variable","name":"0_vm[20]"},"set":{"type":"LessThan","upper":1.1}},{"function":{"type":"Variable","name":"0_vm[12]"},"set":{"type":"LessThan","upper":1.1}},{"function":{"type":"Variable","name":"0_vm[24]"},"set":{"type":"LessThan","upper":1.1}},{"function":{"type":"Variable","name":"0_vm[28]"},"set":{"type":"LessThan","upper":1.1}},{"function":{"type":"Variable","name":"0_vm[8]"},"set":{"type":"LessThan","upper":1.1}},{"function":{"type":"Variable","name":"0_vm[17]"},"set":{"type":"LessThan","upper":1.1}},{"function":{"type":"Variable","name":"0_vm[1]"},"set":{"type":"LessThan","upper":1.1}},{"function":{"type":"Variable","name":"0_vm[23]"},"set":{"type":"LessThan","upper":1.1}},{"function":{"type":"Variable","name":"0_vm[22]"},"set":{"type":"LessThan","upper":1.1}},{"function":{"type":"Variable","name":"0_vm[19]"},"set":{"type":"LessThan","upper":1.1}},{"function":{"type":"Variable","name":"0_vm[6]"},"set":{"type":"LessThan","upper":1.1}},{"function":{"type":"Variable","name":"0_vm[11]"},"set":{"type":"LessThan","upper":1.1}},{"function":{"type":"Variable","name":"0_vm[9]"},"set":{"type":"LessThan","upper":1.1}},{"function":{"type":"Variable","name":"0_vm[14]"},"set":{"type":"LessThan","upper":1.1}},{"function":{"type":"Variable","name":"0_vm[3]"},"set":{"type":"LessThan","upper":1.1}},{"function":{"type":"Variable","name":"0_vm[7]"},"set":{"type":"LessThan","upper":1.1}},{"function":{"type":"Variable","name":"0_vm[25]"},"set":{"type":"LessThan","upper":1.1}},{"function":{"type":"Variable","name":"0_vm[4]"},"set":{"type":"LessThan","upper":1.1}},{"function":{"type":"Variable","name":"0_vm[13]"},"set":{"type":"LessThan","upper":1.1}},{"function":{"type":"Variable","name":"0_vm[15]"},"set":{"type":"LessThan","upper":1.1}},{"function":{"type":"Variable","name":"0_vm[2]"},"set":{"type":"LessThan","upper":1.1}},{"function":{"type":"Variable","name":"0_vm[27]"},"set":{"type":"LessThan","upper":1.1}},{"function":{"type":"Variable","name":"0_vm[21]"},"set":{"type":"LessThan","upper":1.1}},{"function":{"type":"Variable","name":"0_vm[26]"},"set":{"type":"LessThan","upper":1.1}},{"function":{"type":"Variable","name":"0_vm[10]"},"set":{"type":"LessThan","upper":1.1}},{"function":{"type":"Variable","name":"0_vm[18]"},"set":{"type":"LessThan","upper":1.1}},{"function":{"type":"Variable","name":"0_pg[5]"},"set":{"type":"LessThan","upper":0.153}},{"function":{"type":"Variable","name":"0_pg[16]"},"set":{"type":"LessThan","upper":0.149}},{"function":{"type":"Variable","name":"0_pg[20]"},"set":{"type":"LessThan","upper":0.07339999999999999}},{"function":{"type":"Variable","name":"0_pg[12]"},"set":{"type":"LessThan","upper":0.3381}},{"function":{"type":"Variable","name":"0_pg[24]"},"set":{"type":"LessThan","upper":0.72}},{"function":{"type":"Variable","name":"0_pg[28]"},"set":{"type":"LessThan","upper":0.7090000000000001}},{"function":{"type":"Variable","name":"0_pg[8]"},"set":{"type":"LessThan","upper":0.1888}},{"function":{"type":"Variable","name":"0_pg[17]"},"set":{"type":"LessThan","upper":0.149}},{"function":{"type":"Variable","name":"0_pg[30]"},"set":{"type":"LessThan","upper":0.04}},{"function":{"type":"Variable","name":"0_pg[1]"},"set":{"type":"LessThan","upper":0.1826}},{"function":{"type":"Variable","name":"0_pg[23]"},"set":{"type":"LessThan","upper":0.10800000000000001}},{"function":{"type":"Variable","name":"0_pg[32]"},"set":{"type":"LessThan","upper":0.4917}},{"function":{"type":"Variable","name":"0_pg[22]"},"set":{"type":"LessThan","upper":0.1494}},{"function":{"type":"Variable","name":"0_pg[6]"},"set":{"type":"LessThan","upper":0.1696}},{"function":{"type":"Variable","name":"0_pg[19]"},"set":{"type":"LessThan","upper":0.07339999999999999}},{"function":{"type":"Variable","name":"0_pg[11]"},"set":{"type":"LessThan","upper":0.3381}},{"function":{"type":"Variable","name":"0_pg[31]"},"set":{"type":"LessThan","upper":0.3367}},{"function":{"type":"Variable","name":"0_pg[9]"},"set":{"type":"LessThan","upper":0.5175}},{"function":{"type":"Variable","name":"0_pg[14]"},"set":{"type":"LessThan","upper":0.4497}},{"function":{"type":"Variable","name":"0_pg[3]"},"set":{"type":"LessThan","upper":0.1523}},{"function":{"type":"Variable","name":"0_pg[29]"},"set":{"type":"LessThan","upper":1.08}},{"function":{"type":"Variable","name":"0_pg[33]"},"set":{"type":"LessThan","upper":0.0101}},{"function":{"type":"Variable","name":"0_pg[25]"},"set":{"type":"LessThan","upper":0.54}},{"function":{"type":"Variable","name":"0_pg[7]"},"set":{"type":"LessThan","upper":0.1757}},{"function":{"type":"Variable","name":"0_pg[34]"},"set":{"type":"LessThan","upper":0.081}},{"function":{"type":"Variable","name":"0_pg[4]"},"set":{"type":"LessThan","upper":0.1623}},{"function":{"type":"Variable","name":"0_pg[13]"},"set":{"type":"LessThan","upper":0.4497}},{"function":{"type":"Variable","name":"0_pg[15]"},"set":{"type":"LessThan","upper":0.1483}},{"function":{"type":"Variable","name":"0_pg[2]"},"set":{"type":"LessThan","upper":0.1593}},{"function":{"type":"Variable","name":"0_pg[27]"},"set":{"type":"LessThan","upper":0.184}},{"function":{"type":"Variable","name":"0_pg[21]"},"set":{"type":"LessThan","upper":0.1134}},{"function":{"type":"Variable","name":"0_pg[26]"},"set":{"type":"LessThan","upper":0.076}},{"function":{"type":"Variable","name":"0_pg[10]"},"set":{"type":"LessThan","upper":0.5175}},{"function":{"type":"Variable","name":"0_pg[18]"},"set":{"type":"LessThan","upper":0.149}},{"function":{"type":"Variable","name":"0_qg[5]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[16]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[20]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[12]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[24]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[28]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[8]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[17]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[30]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[1]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[23]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[32]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[22]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[6]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[19]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[11]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[31]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[9]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[14]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[3]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[29]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[33]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[25]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[7]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[34]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[4]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[13]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[15]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[2]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[27]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[21]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[26]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[10]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[18]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_p[(5, 5, 6)]"},"set":{"type":"LessThan","upper":0.7}},{"function":{"type":"Variable","name":"0_p[(16, 13, 14)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(20, 16, 17)]"},"set":{"type":"LessThan","upper":0.25}},{"function":{"type":"Variable","name":"0_p[(12, 9, 12)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(24, 21, 22)]"},"set":{"type":"LessThan","upper":0.25}},{"function":{"type":"Variable","name":"0_p[(28, 25, 26)]"},"set":{"type":"LessThan","upper":0.13}},{"function":{"type":"Variable","name":"0_p[(8, 7, 8)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(17, 14, 15)]"},"set":{"type":"LessThan","upper":0.5}},{"function":{"type":"Variable","name":"0_p[(30, 19, 28)]"},"set":{"type":"LessThan","upper":1.0}},{"function":{"type":"Variable","name":"0_p[(1, 2, 1)]"},"set":{"type":"LessThan","upper":0.7}},{"function":{"type":"Variable","name":"0_p[(23, 20, 21)]"},"set":{"type":"LessThan","upper":0.47}},{"function":{"type":"Variable","name":"0_p[(22, 16, 19)]"},"set":{"type":"LessThan","upper":1.06}},{"function":{"type":"Variable","name":"0_p[(19, 14, 16)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(6, 5, 11)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_p[(11, 9, 10)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(31, 19, 28)]"},"set":{"type":"LessThan","upper":1.0}},{"function":{"type":"Variable","name":"0_p[(9, 7, 10)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(14, 11, 18)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_p[(3, 3, 4)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_p[(29, 17, 27)]"},"set":{"type":"LessThan","upper":2.0}},{"function":{"type":"Variable","name":"0_p[(7, 6, 7)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(25, 22, 23)]"},"set":{"type":"LessThan","upper":0.33}},{"function":{"type":"Variable","name":"0_p[(4, 4, 5)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_p[(13, 9, 16)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(15, 12, 13)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(2, 2, 3)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_p[(27, 24, 25)]"},"set":{"type":"LessThan","upper":0.13}},{"function":{"type":"Variable","name":"0_p[(21, 18, 16)]"},"set":{"type":"LessThan","upper":1.0}},{"function":{"type":"Variable","name":"0_p[(26, 23, 24)]"},"set":{"type":"LessThan","upper":0.13}},{"function":{"type":"Variable","name":"0_p[(10, 8, 9)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(18, 14, 20)]"},"set":{"type":"LessThan","upper":0.47}},{"function":{"type":"Variable","name":"0_p[(5, 6, 5)]"},"set":{"type":"LessThan","upper":0.7}},{"function":{"type":"Variable","name":"0_p[(16, 14, 13)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(20, 17, 16)]"},"set":{"type":"LessThan","upper":0.25}},{"function":{"type":"Variable","name":"0_p[(12, 12, 9)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(24, 22, 21)]"},"set":{"type":"LessThan","upper":0.25}},{"function":{"type":"Variable","name":"0_p[(28, 26, 25)]"},"set":{"type":"LessThan","upper":0.13}},{"function":{"type":"Variable","name":"0_p[(8, 8, 7)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(17, 15, 14)]"},"set":{"type":"LessThan","upper":0.5}},{"function":{"type":"Variable","name":"0_p[(30, 28, 19)]"},"set":{"type":"LessThan","upper":1.0}},{"function":{"type":"Variable","name":"0_p[(1, 1, 2)]"},"set":{"type":"LessThan","upper":0.7}},{"function":{"type":"Variable","name":"0_p[(23, 21, 20)]"},"set":{"type":"LessThan","upper":0.47}},{"function":{"type":"Variable","name":"0_p[(22, 19, 16)]"},"set":{"type":"LessThan","upper":1.06}},{"function":{"type":"Variable","name":"0_p[(19, 16, 14)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(6, 11, 5)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_p[(11, 10, 9)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(31, 28, 19)]"},"set":{"type":"LessThan","upper":1.0}},{"function":{"type":"Variable","name":"0_p[(9, 10, 7)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(14, 18, 11)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_p[(3, 4, 3)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_p[(29, 27, 17)]"},"set":{"type":"LessThan","upper":2.0}},{"function":{"type":"Variable","name":"0_p[(7, 7, 6)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(25, 23, 22)]"},"set":{"type":"LessThan","upper":0.33}},{"function":{"type":"Variable","name":"0_p[(4, 5, 4)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_p[(13, 16, 9)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(15, 13, 12)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(2, 3, 2)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_p[(27, 25, 24)]"},"set":{"type":"LessThan","upper":0.13}},{"function":{"type":"Variable","name":"0_p[(21, 16, 18)]"},"set":{"type":"LessThan","upper":1.0}},{"function":{"type":"Variable","name":"0_p[(26, 24, 23)]"},"set":{"type":"LessThan","upper":0.13}},{"function":{"type":"Variable","name":"0_p[(10, 9, 8)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(18, 20, 14)]"},"set":{"type":"LessThan","upper":0.47}},{"function":{"type":"Variable","name":"0_q[(5, 5, 6)]"},"set":{"type":"LessThan","upper":0.7}},{"function":{"type":"Variable","name":"0_q[(16, 13, 14)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(20, 16, 17)]"},"set":{"type":"LessThan","upper":0.25}},{"function":{"type":"Variable","name":"0_q[(12, 9, 12)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(24, 21, 22)]"},"set":{"type":"LessThan","upper":0.25}},{"function":{"type":"Variable","name":"0_q[(28, 25, 26)]"},"set":{"type":"LessThan","upper":0.13}},{"function":{"type":"Variable","name":"0_q[(8, 7, 8)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(17, 14, 15)]"},"set":{"type":"LessThan","upper":0.5}},{"function":{"type":"Variable","name":"0_q[(30, 19, 28)]"},"set":{"type":"LessThan","upper":1.0}},{"function":{"type":"Variable","name":"0_q[(1, 2, 1)]"},"set":{"type":"LessThan","upper":0.7}},{"function":{"type":"Variable","name":"0_q[(23, 20, 21)]"},"set":{"type":"LessThan","upper":0.47}},{"function":{"type":"Variable","name":"0_q[(22, 16, 19)]"},"set":{"type":"LessThan","upper":1.06}},{"function":{"type":"Variable","name":"0_q[(19, 14, 16)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(6, 5, 11)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_q[(11, 9, 10)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(31, 19, 28)]"},"set":{"type":"LessThan","upper":1.0}},{"function":{"type":"Variable","name":"0_q[(9, 7, 10)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(14, 11, 18)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_q[(3, 3, 4)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_q[(29, 17, 27)]"},"set":{"type":"LessThan","upper":2.0}},{"function":{"type":"Variable","name":"0_q[(7, 6, 7)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(25, 22, 23)]"},"set":{"type":"LessThan","upper":0.33}},{"function":{"type":"Variable","name":"0_q[(4, 4, 5)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_q[(13, 9, 16)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(15, 12, 13)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(2, 2, 3)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_q[(27, 24, 25)]"},"set":{"type":"LessThan","upper":0.13}},{"function":{"type":"Variable","name":"0_q[(21, 18, 16)]"},"set":{"type":"LessThan","upper":1.0}},{"function":{"type":"Variable","name":"0_q[(26, 23, 24)]"},"set":{"type":"LessThan","upper":0.13}},{"function":{"type":"Variable","name":"0_q[(10, 8, 9)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(18, 14, 20)]"},"set":{"type":"LessThan","upper":0.47}},{"function":{"type":"Variable","name":"0_q[(5, 6, 5)]"},"set":{"type":"LessThan","upper":0.7}},{"function":{"type":"Variable","name":"0_q[(16, 14, 13)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(20, 17, 16)]"},"set":{"type":"LessThan","upper":0.25}},{"function":{"type":"Variable","name":"0_q[(12, 12, 9)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(24, 22, 21)]"},"set":{"type":"LessThan","upper":0.25}},{"function":{"type":"Variable","name":"0_q[(28, 26, 25)]"},"set":{"type":"LessThan","upper":0.13}},{"function":{"type":"Variable","name":"0_q[(8, 8, 7)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(17, 15, 14)]"},"set":{"type":"LessThan","upper":0.5}},{"function":{"type":"Variable","name":"0_q[(30, 28, 19)]"},"set":{"type":"LessThan","upper":1.0}},{"function":{"type":"Variable","name":"0_q[(1, 1, 2)]"},"set":{"type":"LessThan","upper":0.7}},{"function":{"type":"Variable","name":"0_q[(23, 21, 20)]"},"set":{"type":"LessThan","upper":0.47}},{"function":{"type":"Variable","name":"0_q[(22, 19, 16)]"},"set":{"type":"LessThan","upper":1.06}},{"function":{"type":"Variable","name":"0_q[(19, 16, 14)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(6, 11, 5)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_q[(11, 10, 9)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(31, 28, 19)]"},"set":{"type":"LessThan","upper":1.0}},{"function":{"type":"Variable","name":"0_q[(9, 10, 7)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(14, 18, 11)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_q[(3, 4, 3)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_q[(29, 27, 17)]"},"set":{"type":"LessThan","upper":2.0}},{"function":{"type":"Variable","name":"0_q[(7, 7, 6)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(25, 23, 22)]"},"set":{"type":"LessThan","upper":0.33}},{"function":{"type":"Variable","name":"0_q[(4, 5, 4)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_q[(13, 16, 9)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(15, 13, 12)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(2, 3, 2)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_q[(27, 25, 24)]"},"set":{"type":"LessThan","upper":0.13}},{"function":{"type":"Variable","name":"0_q[(21, 16, 18)]"},"set":{"type":"LessThan","upper":1.0}},{"function":{"type":"Variable","name":"0_q[(26, 24, 23)]"},"set":{"type":"LessThan","upper":0.13}},{"function":{"type":"Variable","name":"0_q[(10, 9, 8)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(18, 20, 14)]"},"set":{"type":"LessThan","upper":0.47}},{"function":{"type":"Variable","name":"reservoir[1]_out"},"set":{"type":"LessThan","upper":0.1}},{"function":{"type":"Variable","name":"reservoir[2]_out"},"set":{"type":"LessThan","upper":137.99}},{"function":{"type":"Variable","name":"reservoir[3]_out"},"set":{"type":"LessThan","upper":0.042}},{"function":{"type":"Variable","name":"reservoir[4]_out"},"set":{"type":"LessThan","upper":16.76}},{"function":{"type":"Variable","name":"reservoir[5]_out"},"set":{"type":"LessThan","upper":10.35}},{"function":{"type":"Variable","name":"reservoir[6]_out"},"set":{"type":"LessThan","upper":0.32}},{"function":{"type":"Variable","name":"reservoir[7]_out"},"set":{"type":"LessThan","upper":9.72}},{"function":{"type":"Variable","name":"reservoir[8]_out"},"set":{"type":"LessThan","upper":0.07}},{"function":{"type":"Variable","name":"reservoir[9]_out"},"set":{"type":"LessThan","upper":0.04}},{"function":{"type":"Variable","name":"reservoir[10]_out"},"set":{"type":"LessThan","upper":0.0}},{"function":{"type":"Variable","name":"reservoir[11]_out"},"set":{"type":"LessThan","upper":2.93}},{"function":{"type":"Variable","name":"outflow[1]"},"set":{"type":"LessThan","upper":10.2926}},{"function":{"type":"Variable","name":"outflow[2]"},"set":{"type":"LessThan","upper":10.5531}},{"function":{"type":"Variable","name":"outflow[3]"},"set":{"type":"LessThan","upper":0.7854}},{"function":{"type":"Variable","name":"outflow[4]"},"set":{"type":"LessThan","upper":3.63}},{"function":{"type":"Variable","name":"outflow[5]"},"set":{"type":"LessThan","upper":8.74}},{"function":{"type":"Variable","name":"outflow[6]"},"set":{"type":"LessThan","upper":17.01}},{"function":{"type":"Variable","name":"outflow[7]"},"set":{"type":"LessThan","upper":1.25}},{"function":{"type":"Variable","name":"outflow[8]"},"set":{"type":"LessThan","upper":7.0}},{"function":{"type":"Variable","name":"outflow[9]"},"set":{"type":"LessThan","upper":11.0}},{"function":{"type":"Variable","name":"outflow[10]"},"set":{"type":"LessThan","upper":0.84}},{"function":{"type":"Variable","name":"outflow[11]"},"set":{"type":"LessThan","upper":3.24}}]} \ No newline at end of file diff --git a/examples/HydroPowerModels/bolivia/DCPPowerModel.mof.json b/examples/HydroPowerModels/bolivia/DCPPowerModel.mof.json index b9cd177..05c24ea 100644 --- a/examples/HydroPowerModels/bolivia/DCPPowerModel.mof.json +++ b/examples/HydroPowerModels/bolivia/DCPPowerModel.mof.json @@ -1,7018 +1 @@ -{ - "name": "MathOptFormat Model", - "version": { - "major": 1, - "minor": 7 - }, - "variables": [ - { - "name": "reservoir[1]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[2]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[3]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[4]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[5]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[6]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[7]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[8]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[9]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[10]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[11]_in", - "primal_start": 0.0 - }, - { - "name": "inflow[1]", - "primal_start": 0.0 - }, - { - "name": "inflow[2]", - "primal_start": 0.0 - }, - { - "name": "inflow[3]", - "primal_start": 0.0 - }, - { - "name": "inflow[4]", - "primal_start": 0.0 - }, - { - "name": "inflow[5]", - "primal_start": 0.0 - }, - { - "name": "inflow[6]", - "primal_start": 0.0 - }, - { - "name": "inflow[7]", - "primal_start": 0.0 - }, - { - "name": "inflow[8]", - "primal_start": 0.0 - }, - { - "name": "inflow[9]", - "primal_start": 0.0 - }, - { - "name": "inflow[10]", - "primal_start": 0.0 - }, - { - "name": "inflow[11]", - "primal_start": 0.0 - }, - { - "name": "0_pg[5]", - "primal_start": 0.0 - }, - { - "name": "0_pg[16]", - "primal_start": 0.0 - }, - { - "name": "0_pg[20]", - "primal_start": 0.0 - }, - { - "name": "0_pg[12]", - "primal_start": 0.0 - }, - { - "name": "0_pg[24]", - "primal_start": 0.0 - }, - { - "name": "0_pg[28]", - "primal_start": 0.0 - }, - { - "name": "0_pg[8]", - "primal_start": 0.0 - }, - { - "name": "0_pg[17]", - "primal_start": 0.0 - }, - { - "name": "0_pg[30]", - "primal_start": 0.0 - }, - { - "name": "0_pg[1]", - "primal_start": 0.0 - }, - { - "name": "0_pg[23]", - "primal_start": 0.0 - }, - { - "name": "0_pg[32]", - "primal_start": 0.0 - }, - { - "name": "0_pg[22]", - "primal_start": 0.0 - }, - { - "name": "0_pg[6]", - "primal_start": 0.0 - }, - { - "name": "0_pg[19]", - "primal_start": 0.0 - }, - { - "name": "0_pg[11]", - "primal_start": 0.0 - }, - { - "name": "0_pg[31]", - "primal_start": 0.0 - }, - { - "name": "0_pg[9]", - "primal_start": 0.0 - }, - { - "name": "0_pg[14]", - "primal_start": 0.0 - }, - { - "name": "0_pg[3]", - "primal_start": 0.0 - }, - { - "name": "0_pg[29]", - "primal_start": 0.0 - }, - { - "name": "0_pg[33]", - "primal_start": 0.0 - }, - { - "name": "0_pg[25]", - "primal_start": 0.0 - }, - { - "name": "0_pg[7]", - "primal_start": 0.0 - }, - { - "name": "0_pg[34]", - "primal_start": 0.0 - }, - { - "name": "0_pg[4]", - "primal_start": 0.0 - }, - { - "name": "0_pg[13]", - "primal_start": 0.0 - }, - { - "name": "0_pg[15]", - "primal_start": 0.0 - }, - { - "name": "0_pg[2]", - "primal_start": 0.0 - }, - { - "name": "0_pg[27]", - "primal_start": 0.0 - }, - { - "name": "0_pg[21]", - "primal_start": 0.0 - }, - { - "name": "0_pg[26]", - "primal_start": 0.0 - }, - { - "name": "0_pg[10]", - "primal_start": 0.0 - }, - { - "name": "0_pg[18]", - "primal_start": 0.0 - }, - { - "name": "0_p[(5, 5, 6)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(16, 13, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(20, 16, 17)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(12, 9, 12)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(24, 21, 22)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(28, 25, 26)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(8, 7, 8)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(17, 14, 15)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(30, 19, 28)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(1, 2, 1)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(23, 20, 21)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(22, 16, 19)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(19, 14, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(6, 5, 11)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(11, 9, 10)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(31, 19, 28)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(9, 7, 10)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(14, 11, 18)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(3, 3, 4)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(29, 17, 27)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(7, 6, 7)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(25, 22, 23)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(4, 4, 5)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(13, 9, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(15, 12, 13)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(2, 2, 3)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(27, 24, 25)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(21, 18, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(26, 23, 24)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(10, 8, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(18, 14, 20)]", - "primal_start": 0.0 - }, - { - "name": "reservoir[1]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[2]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[3]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[4]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[5]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[6]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[7]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[8]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[9]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[10]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[11]_out", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[1]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[2]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[3]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[4]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[5]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[6]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[7]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[8]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[9]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[10]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[11]", - "primal_start": 0.0 - }, - { - "name": "outflow[1]", - "primal_start": 0.0 - }, - { - "name": "outflow[2]", - "primal_start": 0.0 - }, - { - "name": "outflow[3]", - "primal_start": 0.0 - }, - { - "name": "outflow[4]", - "primal_start": 0.0 - }, - { - "name": "outflow[5]", - "primal_start": 0.0 - }, - { - "name": "outflow[6]", - "primal_start": 0.0 - }, - { - "name": "outflow[7]", - "primal_start": 0.0 - }, - { - "name": "outflow[8]", - "primal_start": 0.0 - }, - { - "name": "outflow[9]", - "primal_start": 0.0 - }, - { - "name": "outflow[10]", - "primal_start": 0.0 - }, - { - "name": "outflow[11]", - "primal_start": 0.0 - }, - { - "name": "spill[1]", - "primal_start": 0.0 - }, - { - "name": "spill[2]", - "primal_start": 0.0 - }, - { - "name": "spill[3]", - "primal_start": 0.0 - }, - { - "name": "spill[4]", - "primal_start": 0.0 - }, - { - "name": "spill[5]", - "primal_start": 0.0 - }, - { - "name": "spill[6]", - "primal_start": 0.0 - }, - { - "name": "spill[7]", - "primal_start": 0.0 - }, - { - "name": "spill[8]", - "primal_start": 0.0 - }, - { - "name": "spill[9]", - "primal_start": 0.0 - }, - { - "name": "spill[10]", - "primal_start": 0.0 - }, - { - "name": "spill[11]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[1]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[2]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[3]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[4]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[5]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[6]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[7]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[8]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[9]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[10]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[11]", - "primal_start": 0.0 - }, - { - "name": "deficit[1]", - "primal_start": 0.0 - }, - { - "name": "deficit[2]", - "primal_start": 0.0 - }, - { - "name": "deficit[3]", - "primal_start": 0.0 - }, - { - "name": "deficit[4]", - "primal_start": 0.0 - }, - { - "name": "deficit[5]", - "primal_start": 0.0 - }, - { - "name": "deficit[6]", - "primal_start": 0.0 - }, - { - "name": "deficit[7]", - "primal_start": 0.0 - }, - { - "name": "deficit[8]", - "primal_start": 0.0 - }, - { - "name": "deficit[9]", - "primal_start": 0.0 - }, - { - "name": "deficit[10]", - "primal_start": 0.0 - }, - { - "name": "deficit[11]", - "primal_start": 0.0 - }, - { - "name": "deficit[12]", - "primal_start": 0.0 - }, - { - "name": "deficit[13]", - "primal_start": 0.0 - }, - { - "name": "deficit[14]", - "primal_start": 0.0 - }, - { - "name": "deficit[15]", - "primal_start": 0.0 - }, - { - "name": "deficit[16]", - "primal_start": 0.0 - }, - { - "name": "deficit[17]", - "primal_start": 0.0 - }, - { - "name": "deficit[18]", - "primal_start": 0.0 - }, - { - "name": "deficit[19]", - "primal_start": 0.0 - }, - { - "name": "deficit[20]", - "primal_start": 0.0 - }, - { - "name": "deficit[21]", - "primal_start": 0.0 - }, - { - "name": "deficit[22]", - "primal_start": 0.0 - }, - { - "name": "deficit[23]", - "primal_start": 0.0 - }, - { - "name": "deficit[24]", - "primal_start": 0.0 - }, - { - "name": "deficit[25]", - "primal_start": 0.0 - }, - { - "name": "deficit[26]", - "primal_start": 0.0 - }, - { - "name": "deficit[27]", - "primal_start": 0.0 - }, - { - "name": "deficit[28]", - "primal_start": 0.0 - }, - { - "name": "0_va[5]", - "primal_start": 0.0 - }, - { - "name": "0_va[16]", - "primal_start": 0.0 - }, - { - "name": "0_va[20]", - "primal_start": 0.0 - }, - { - "name": "0_va[12]", - "primal_start": 0.0 - }, - { - "name": "0_va[24]", - "primal_start": 0.0 - }, - { - "name": "0_va[28]", - "primal_start": 0.0 - }, - { - "name": "0_va[8]", - "primal_start": 0.0 - }, - { - "name": "0_va[17]", - "primal_start": 0.0 - }, - { - "name": "0_va[1]", - "primal_start": 0.0 - }, - { - "name": "0_va[23]", - "primal_start": 0.0 - }, - { - "name": "0_va[22]", - "primal_start": 0.0 - }, - { - "name": "0_va[19]", - "primal_start": 0.0 - }, - { - "name": "0_va[6]", - "primal_start": 0.0 - }, - { - "name": "0_va[11]", - "primal_start": 0.0 - }, - { - "name": "0_va[9]", - "primal_start": 0.0 - }, - { - "name": "0_va[14]", - "primal_start": 0.0 - }, - { - "name": "0_va[3]", - "primal_start": 0.0 - }, - { - "name": "0_va[7]", - "primal_start": 0.0 - }, - { - "name": "0_va[25]", - "primal_start": 0.0 - }, - { - "name": "0_va[4]", - "primal_start": 0.0 - }, - { - "name": "0_va[13]", - "primal_start": 0.0 - }, - { - "name": "0_va[15]", - "primal_start": 0.0 - }, - { - "name": "0_va[2]", - "primal_start": 0.0 - }, - { - "name": "0_va[27]", - "primal_start": 0.0 - }, - { - "name": "0_va[21]", - "primal_start": 0.0 - }, - { - "name": "0_va[26]", - "primal_start": 0.0 - }, - { - "name": "0_va[10]", - "primal_start": 0.0 - }, - { - "name": "0_va[18]", - "primal_start": 0.0 - } - ], - "objective": { - "sense": "min", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 6000.0, - "variable": "deficit[1]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[2]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[3]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[4]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[5]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[6]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[7]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[8]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[9]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[10]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[11]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[12]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[13]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[14]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[15]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[16]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[17]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[18]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[19]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[20]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[21]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[22]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[23]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[24]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[25]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[26]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[27]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[28]" - }, - { - "coefficient": 2268.0, - "variable": "0_pg[5]" - }, - { - "coefficient": 2059.0, - "variable": "0_pg[16]" - }, - { - "coefficient": 1780.0, - "variable": "0_pg[20]" - }, - { - "coefficient": 1576.0, - "variable": "0_pg[12]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[24]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[28]" - }, - { - "coefficient": 1754.0, - "variable": "0_pg[8]" - }, - { - "coefficient": 2059.0, - "variable": "0_pg[17]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[30]" - }, - { - "coefficient": 1918.0, - "variable": "0_pg[1]" - }, - { - "coefficient": 4244.0, - "variable": "0_pg[23]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[32]" - }, - { - "coefficient": 1517.0, - "variable": "0_pg[22]" - }, - { - "coefficient": 2131.0, - "variable": "0_pg[6]" - }, - { - "coefficient": 1780.0, - "variable": "0_pg[19]" - }, - { - "coefficient": 1576.0, - "variable": "0_pg[11]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[31]" - }, - { - "coefficient": 1576.0, - "variable": "0_pg[9]" - }, - { - "coefficient": 1404.0, - "variable": "0_pg[14]" - }, - { - "coefficient": 2184.0, - "variable": "0_pg[3]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[29]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[33]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[25]" - }, - { - "coefficient": 1822.0, - "variable": "0_pg[7]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[34]" - }, - { - "coefficient": 2179.0, - "variable": "0_pg[4]" - }, - { - "coefficient": 1404.0, - "variable": "0_pg[13]" - }, - { - "coefficient": 2077.0, - "variable": "0_pg[15]" - }, - { - "coefficient": 2120.0, - "variable": "0_pg[2]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[27]" - }, - { - "coefficient": 1598.0, - "variable": "0_pg[21]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[26]" - }, - { - "coefficient": 1576.0, - "variable": "0_pg[10]" - }, - { - "coefficient": 2059.0, - "variable": "0_pg[18]" - } - ], - "constant": 0.0 - } - }, - "constraints": [ - { - "name": "c1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(5, 5, 6)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(6, 5, 11)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(4, 4, 5)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[5]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c3", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(20, 16, 17)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(22, 16, 19)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(19, 14, 16)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(13, 9, 16)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(21, 18, 16)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[16]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.21439096103324617 - } - }, - { - "name": "c4", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(23, 20, 21)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(18, 14, 20)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[20]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.0015565421870758504 - } - }, - { - "name": "c5", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_p[(12, 9, 12)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(15, 12, 13)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[12]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.05738794110411041 - } - }, - { - "name": "c6", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(27, 24, 25)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(26, 23, 24)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[24]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.01804043447630477 - } - }, - { - "name": "c7", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[28]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[30]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[29]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(30, 19, 28)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(31, 19, 28)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[28]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c8", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[25]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(8, 7, 8)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(10, 8, 9)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[8]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c9", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_p[(20, 16, 17)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(29, 17, 27)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[17]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.267753330934522 - } - }, - { - "name": "c10", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[5]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[8]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[1]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[6]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[9]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[3]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[7]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[4]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[2]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[10]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(1, 2, 1)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.6075543555612704 - } - }, - { - "name": "c11", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[21]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(25, 22, 23)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(26, 23, 24)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[23]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.0004825663866386638 - } - }, - { - "name": "c12", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[34]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(24, 21, 22)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(25, 22, 23)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[22]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.12074817048704867 - } - }, - { - "name": "c13", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[20]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[32]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[19]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[31]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[33]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(30, 19, 28)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(22, 16, 19)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(31, 19, 28)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[19]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.4735118986170044 - } - }, - { - "name": "c14", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_p[(5, 5, 6)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(7, 6, 7)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c15", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_p[(6, 5, 11)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(14, 11, 18)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c16", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[16]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[17]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[15]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[18]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(12, 9, 12)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(11, 9, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(13, 9, 16)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(10, 8, 9)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.21593913974111698 - } - }, - { - "name": "c17", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_p[(16, 13, 14)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(17, 14, 15)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(19, 14, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(18, 14, 20)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[14]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c18", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[12]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[11]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[14]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[13]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 3, 4)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(2, 2, 3)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c19", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[24]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(8, 7, 8)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(9, 7, 10)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(7, 6, 7)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c20", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(28, 25, 26)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(27, 24, 25)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[25]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.0004825663866386638 - } - }, - { - "name": "c21", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_p[(3, 3, 4)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(4, 4, 5)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.02040724338005229 - } - }, - { - "name": "c22", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(16, 13, 14)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(15, 12, 13)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[13]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.0004825663866386638 - } - }, - { - "name": "c23", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_p[(17, 14, 15)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[15]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.10015864047547611 - } - }, - { - "name": "c24", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(1, 2, 1)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c25", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[27]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(29, 17, 27)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[27]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c26", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(24, 21, 22)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(23, 20, 21)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[21]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c27", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[23]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[22]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(28, 25, 26)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[26]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.1700922829782978 - } - }, - { - "name": "c28", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[26]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(11, 9, 10)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(9, 7, 10)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.5563327884359863 - } - }, - { - "name": "c29", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_p[(14, 11, 18)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(21, 18, 16)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[18]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c30", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(5, 5, 6)]" - }, - { - "coefficient": -12.485777918589607, - "variable": "0_va[5]" - }, - { - "coefficient": 12.485777918589607, - "variable": "0_va[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c31", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(16, 13, 14)]" - }, - { - "coefficient": 6.795713842466891, - "variable": "0_va[14]" - }, - { - "coefficient": -6.795713842466891, - "variable": "0_va[13]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c32", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(20, 16, 17)]" - }, - { - "coefficient": -10.149298248521102, - "variable": "0_va[16]" - }, - { - "coefficient": 10.149298248521102, - "variable": "0_va[17]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c33", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(12, 9, 12)]" - }, - { - "coefficient": 6.481250938450924, - "variable": "0_va[12]" - }, - { - "coefficient": -6.481250938450924, - "variable": "0_va[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c34", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(24, 21, 22)]" - }, - { - "coefficient": 4.2328983731321435, - "variable": "0_va[22]" - }, - { - "coefficient": -4.2328983731321435, - "variable": "0_va[21]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c35", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(28, 25, 26)]" - }, - { - "coefficient": -2.091029561081878, - "variable": "0_va[25]" - }, - { - "coefficient": 2.091029561081878, - "variable": "0_va[26]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c36", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(8, 7, 8)]" - }, - { - "coefficient": 45.39453875906154, - "variable": "0_va[8]" - }, - { - "coefficient": -45.39453875906154, - "variable": "0_va[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c37", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(17, 14, 15)]" - }, - { - "coefficient": -19.8968547052082, - "variable": "0_va[14]" - }, - { - "coefficient": 19.8968547052082, - "variable": "0_va[15]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c38", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(30, 19, 28)]" - }, - { - "coefficient": 9.121944633618186, - "variable": "0_va[28]" - }, - { - "coefficient": -9.121944633618186, - "variable": "0_va[19]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c39", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(1, 2, 1)]" - }, - { - "coefficient": 9.363115118052471, - "variable": "0_va[1]" - }, - { - "coefficient": -9.363115118052471, - "variable": "0_va[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c40", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(23, 20, 21)]" - }, - { - "coefficient": -3.33399327650884, - "variable": "0_va[20]" - }, - { - "coefficient": 3.33399327650884, - "variable": "0_va[21]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c41", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(22, 16, 19)]" - }, - { - "coefficient": -2.8140484527509644, - "variable": "0_va[16]" - }, - { - "coefficient": 2.8140484527509644, - "variable": "0_va[19]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c42", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(19, 14, 16)]" - }, - { - "coefficient": 3.667991302391842, - "variable": "0_va[16]" - }, - { - "coefficient": -3.667991302391842, - "variable": "0_va[14]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c43", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(6, 5, 11)]" - }, - { - "coefficient": -20.88296190751831, - "variable": "0_va[5]" - }, - { - "coefficient": 20.88296190751831, - "variable": "0_va[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c44", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(11, 9, 10)]" - }, - { - "coefficient": -52.44594387363901, - "variable": "0_va[9]" - }, - { - "coefficient": 52.44594387363901, - "variable": "0_va[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c45", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(31, 19, 28)]" - }, - { - "coefficient": 5.498037005409949, - "variable": "0_va[28]" - }, - { - "coefficient": -5.498037005409949, - "variable": "0_va[19]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c46", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(9, 7, 10)]" - }, - { - "coefficient": -6.467289330533839, - "variable": "0_va[7]" - }, - { - "coefficient": 6.467289330533839, - "variable": "0_va[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c47", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(14, 11, 18)]" - }, - { - "coefficient": -8.698708713000553, - "variable": "0_va[11]" - }, - { - "coefficient": 8.698708713000553, - "variable": "0_va[18]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c48", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(3, 3, 4)]" - }, - { - "coefficient": -17.010777436904807, - "variable": "0_va[3]" - }, - { - "coefficient": 17.010777436904807, - "variable": "0_va[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c49", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(29, 17, 27)]" - }, - { - "coefficient": -1.6861921183958626, - "variable": "0_va[17]" - }, - { - "coefficient": 1.6861921183958626, - "variable": "0_va[27]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c50", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(7, 6, 7)]" - }, - { - "coefficient": -31.512256609281188, - "variable": "0_va[6]" - }, - { - "coefficient": 31.512256609281188, - "variable": "0_va[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c51", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(25, 22, 23)]" - }, - { - "coefficient": 8.939086077602251, - "variable": "0_va[23]" - }, - { - "coefficient": -8.939086077602251, - "variable": "0_va[22]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c52", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(4, 4, 5)]" - }, - { - "coefficient": 16.36003009370084, - "variable": "0_va[5]" - }, - { - "coefficient": -16.36003009370084, - "variable": "0_va[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c53", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(13, 9, 16)]" - }, - { - "coefficient": 1.8998888915041532, - "variable": "0_va[16]" - }, - { - "coefficient": -1.8998888915041532, - "variable": "0_va[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c54", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(15, 12, 13)]" - }, - { - "coefficient": -7.029547007720768, - "variable": "0_va[12]" - }, - { - "coefficient": 7.029547007720768, - "variable": "0_va[13]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c55", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]" - }, - { - "coefficient": 7.165952433825185, - "variable": "0_va[3]" - }, - { - "coefficient": -7.165952433825185, - "variable": "0_va[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c56", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(27, 24, 25)]" - }, - { - "coefficient": -2.868957761798156, - "variable": "0_va[24]" - }, - { - "coefficient": 2.868957761798156, - "variable": "0_va[25]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c57", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(21, 18, 16)]" - }, - { - "coefficient": 11.73125512037617, - "variable": "0_va[16]" - }, - { - "coefficient": -11.73125512037617, - "variable": "0_va[18]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c58", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(26, 23, 24)]" - }, - { - "coefficient": 5.604798539074481, - "variable": "0_va[24]" - }, - { - "coefficient": -5.604798539074481, - "variable": "0_va[23]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c59", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(10, 8, 9)]" - }, - { - "coefficient": -6.776372942488066, - "variable": "0_va[8]" - }, - { - "coefficient": 6.776372942488066, - "variable": "0_va[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c60", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(18, 14, 20)]" - }, - { - "coefficient": 2.875699016068521, - "variable": "0_va[20]" - }, - { - "coefficient": -2.875699016068521, - "variable": "0_va[14]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[1]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[1]" - }, - { - "coefficient": -0.0036, - "variable": "outflow[2]" - }, - { - "coefficient": 1.0, - "variable": "spill[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[2]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[2]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[2]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[2]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[2]" - }, - { - "coefficient": 1.0, - "variable": "spill[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[3]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[3]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[3]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[3]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[3]" - }, - { - "coefficient": 1.0, - "variable": "spill[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[4]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[4]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[4]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[4]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[4]" - }, - { - "coefficient": 1.0, - "variable": "spill[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[5]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[5]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[5]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[5]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[5]" - }, - { - "coefficient": 1.0, - "variable": "spill[5]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[6]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[6]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[6]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[6]_out" - }, - { - "coefficient": -0.0036, - "variable": "outflow[5]" - }, - { - "coefficient": 0.0036, - "variable": "outflow[6]" - }, - { - "coefficient": -1.0, - "variable": "spill[5]" - }, - { - "coefficient": 1.0, - "variable": "spill[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[7]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[7]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[7]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[7]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[7]" - }, - { - "coefficient": 1.0, - "variable": "spill[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[8]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[8]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[8]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[8]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[8]" - }, - { - "coefficient": 1.0, - "variable": "spill[8]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[9]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[9]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[9]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[9]_out" - }, - { - "coefficient": -0.0036, - "variable": "outflow[8]" - }, - { - "coefficient": 0.0036, - "variable": "outflow[9]" - }, - { - "coefficient": -1.0, - "variable": "spill[8]" - }, - { - "coefficient": 1.0, - "variable": "spill[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[10]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[10]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[10]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[10]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[10]" - }, - { - "coefficient": 1.0, - "variable": "spill[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[11]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[11]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[11]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[11]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[11]" - }, - { - "coefficient": 1.0, - "variable": "spill[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[1]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[24]" - }, - { - "coefficient": -6.9953, - "variable": "outflow[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[2]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[25]" - }, - { - "coefficient": -5.117, - "variable": "outflow[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[3]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[26]" - }, - { - "coefficient": -9.677, - "variable": "outflow[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[4]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[27]" - }, - { - "coefficient": -5.06, - "variable": "outflow[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[5]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[28]" - }, - { - "coefficient": -8.11, - "variable": "outflow[5]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[6]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[29]" - }, - { - "coefficient": -6.35, - "variable": "outflow[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[7]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[30]" - }, - { - "coefficient": -3.2, - "variable": "outflow[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[8]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[31]" - }, - { - "coefficient": -4.81, - "variable": "outflow[8]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[9]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[32]" - }, - { - "coefficient": -4.47, - "variable": "outflow[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[10]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[33]" - }, - { - "coefficient": -1.2, - "variable": "outflow[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[11]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[34]" - }, - { - "coefficient": -2.5, - "variable": "outflow[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "min_volume_violation_bound[1]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[1]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[2]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[2]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[3]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[3]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[4]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[4]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[5]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[5]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[5]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[6]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[6]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[7]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[7]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[8]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[8]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[8]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[9]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[9]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[10]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[10]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[11]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[11]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[1]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[2]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[2]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[3]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[3]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[4]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[4]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[5]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[5]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[5]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[6]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[6]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[7]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[7]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[8]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[8]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[8]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[9]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[9]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[10]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[10]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[11]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[11]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c1_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[5]" - }, - { - "coefficient": -1.0, - "variable": "0_va[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c2_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[14]" - }, - { - "coefficient": 1.0, - "variable": "0_va[13]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c3_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[16]" - }, - { - "coefficient": -1.0, - "variable": "0_va[17]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c4_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[12]" - }, - { - "coefficient": 1.0, - "variable": "0_va[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c5_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[22]" - }, - { - "coefficient": 1.0, - "variable": "0_va[21]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c6_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[25]" - }, - { - "coefficient": -1.0, - "variable": "0_va[26]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c7_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[8]" - }, - { - "coefficient": 1.0, - "variable": "0_va[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c8_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[14]" - }, - { - "coefficient": -1.0, - "variable": "0_va[15]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c9_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[28]" - }, - { - "coefficient": 1.0, - "variable": "0_va[19]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c10_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[1]" - }, - { - "coefficient": 1.0, - "variable": "0_va[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c11_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[20]" - }, - { - "coefficient": -1.0, - "variable": "0_va[21]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c12_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[16]" - }, - { - "coefficient": -1.0, - "variable": "0_va[19]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c13_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[16]" - }, - { - "coefficient": 1.0, - "variable": "0_va[14]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c14_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[5]" - }, - { - "coefficient": -1.0, - "variable": "0_va[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c15_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[9]" - }, - { - "coefficient": -1.0, - "variable": "0_va[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c16_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[7]" - }, - { - "coefficient": -1.0, - "variable": "0_va[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c17_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[11]" - }, - { - "coefficient": -1.0, - "variable": "0_va[18]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c18_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[3]" - }, - { - "coefficient": -1.0, - "variable": "0_va[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c19_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[17]" - }, - { - "coefficient": -1.0, - "variable": "0_va[27]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c20_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[6]" - }, - { - "coefficient": -1.0, - "variable": "0_va[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c21_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[23]" - }, - { - "coefficient": 1.0, - "variable": "0_va[22]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c22_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[5]" - }, - { - "coefficient": 1.0, - "variable": "0_va[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c23_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[16]" - }, - { - "coefficient": 1.0, - "variable": "0_va[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c24_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[12]" - }, - { - "coefficient": -1.0, - "variable": "0_va[13]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c25_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]" - }, - { - "coefficient": 1.0, - "variable": "0_va[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c26_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[24]" - }, - { - "coefficient": -1.0, - "variable": "0_va[25]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c27_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[16]" - }, - { - "coefficient": 1.0, - "variable": "0_va[18]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c28_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[24]" - }, - { - "coefficient": 1.0, - "variable": "0_va[23]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c29_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[8]" - }, - { - "coefficient": -1.0, - "variable": "0_va[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c30_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[20]" - }, - { - "coefficient": 1.0, - "variable": "0_va[14]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[2]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[3]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[4]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[5]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[6]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[7]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[8]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[9]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[10]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[11]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[1]" - }, - "set": { - "type": "EqualTo", - "value": 2.511995176219288 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[2]" - }, - "set": { - "type": "EqualTo", - "value": 20.287328815178604 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[3]" - }, - "set": { - "type": "EqualTo", - "value": 0.47051310438920707 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[4]" - }, - "set": { - "type": "EqualTo", - "value": 5.920884899840916 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[5]" - }, - "set": { - "type": "EqualTo", - "value": 8.740098685690562 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[6]" - }, - "set": { - "type": "EqualTo", - "value": 12.202757601522093 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[7]" - }, - "set": { - "type": "EqualTo", - "value": 1.182082511928039 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[8]" - }, - "set": { - "type": "EqualTo", - "value": 7.174922571850988 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[9]" - }, - "set": { - "type": "EqualTo", - "value": 5.793033749093465 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[10]" - }, - "set": { - "type": "EqualTo", - "value": 1.6400117193850288 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[11]" - }, - "set": { - "type": "EqualTo", - "value": 3.196675667842211 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[16]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[20]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[12]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[24]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[28]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[17]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[30]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[23]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[32]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[22]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[19]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[31]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[14]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[29]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[33]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[25]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[34]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[13]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[15]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[27]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[21]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[26]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[18]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(5, 5, 6)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(16, 13, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(20, 16, 17)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(12, 9, 12)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(24, 21, 22)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(28, 25, 26)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(8, 7, 8)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(17, 14, 15)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(30, 19, 28)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 2, 1)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(23, 20, 21)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(22, 16, 19)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(19, 14, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(6, 5, 11)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(11, 9, 10)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(31, 19, 28)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(9, 7, 10)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(14, 11, 18)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 3, 4)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(29, 17, 27)]" - }, - "set": { - "type": "GreaterThan", - "lower": -2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(7, 6, 7)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(25, 22, 23)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(4, 4, 5)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(13, 9, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(15, 12, 13)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(27, 24, 25)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(21, 18, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(26, 23, 24)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(10, 8, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(18, 14, 20)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[2]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[3]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[4]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[5]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[6]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[7]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[8]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[9]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[10]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[11]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[12]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[13]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[14]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[15]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[16]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[17]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[18]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[19]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[20]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[21]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[22]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[23]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[24]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[25]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[26]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[27]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[28]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[5]" - }, - "set": { - "type": "LessThan", - "upper": 0.153 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[16]" - }, - "set": { - "type": "LessThan", - "upper": 0.149 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[20]" - }, - "set": { - "type": "LessThan", - "upper": 0.07339999999999999 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[12]" - }, - "set": { - "type": "LessThan", - "upper": 0.3381 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[24]" - }, - "set": { - "type": "LessThan", - "upper": 0.72 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[28]" - }, - "set": { - "type": "LessThan", - "upper": 0.7090000000000001 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[8]" - }, - "set": { - "type": "LessThan", - "upper": 0.1888 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[17]" - }, - "set": { - "type": "LessThan", - "upper": 0.149 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[30]" - }, - "set": { - "type": "LessThan", - "upper": 0.04 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]" - }, - "set": { - "type": "LessThan", - "upper": 0.1826 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[23]" - }, - "set": { - "type": "LessThan", - "upper": 0.10800000000000001 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[32]" - }, - "set": { - "type": "LessThan", - "upper": 0.4917 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[22]" - }, - "set": { - "type": "LessThan", - "upper": 0.1494 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[6]" - }, - "set": { - "type": "LessThan", - "upper": 0.1696 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[19]" - }, - "set": { - "type": "LessThan", - "upper": 0.07339999999999999 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[11]" - }, - "set": { - "type": "LessThan", - "upper": 0.3381 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[31]" - }, - "set": { - "type": "LessThan", - "upper": 0.3367 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[9]" - }, - "set": { - "type": "LessThan", - "upper": 0.5175 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[14]" - }, - "set": { - "type": "LessThan", - "upper": 0.4497 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]" - }, - "set": { - "type": "LessThan", - "upper": 0.1523 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[29]" - }, - "set": { - "type": "LessThan", - "upper": 1.08 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[33]" - }, - "set": { - "type": "LessThan", - "upper": 0.0101 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[25]" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[7]" - }, - "set": { - "type": "LessThan", - "upper": 0.1757 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[34]" - }, - "set": { - "type": "LessThan", - "upper": 0.081 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[4]" - }, - "set": { - "type": "LessThan", - "upper": 0.1623 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[13]" - }, - "set": { - "type": "LessThan", - "upper": 0.4497 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[15]" - }, - "set": { - "type": "LessThan", - "upper": 0.1483 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]" - }, - "set": { - "type": "LessThan", - "upper": 0.1593 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[27]" - }, - "set": { - "type": "LessThan", - "upper": 0.184 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[21]" - }, - "set": { - "type": "LessThan", - "upper": 0.1134 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[26]" - }, - "set": { - "type": "LessThan", - "upper": 0.076 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[10]" - }, - "set": { - "type": "LessThan", - "upper": 0.5175 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[18]" - }, - "set": { - "type": "LessThan", - "upper": 0.149 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(5, 5, 6)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(16, 13, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(20, 16, 17)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(12, 9, 12)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(24, 21, 22)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(28, 25, 26)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(8, 7, 8)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(17, 14, 15)]" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(30, 19, 28)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 2, 1)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(23, 20, 21)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(22, 16, 19)]" - }, - "set": { - "type": "LessThan", - "upper": 1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(19, 14, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(6, 5, 11)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(11, 9, 10)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(31, 19, 28)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(9, 7, 10)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(14, 11, 18)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 3, 4)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(29, 17, 27)]" - }, - "set": { - "type": "LessThan", - "upper": 2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(7, 6, 7)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(25, 22, 23)]" - }, - "set": { - "type": "LessThan", - "upper": 0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(4, 4, 5)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(13, 9, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(15, 12, 13)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(27, 24, 25)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(21, 18, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(26, 23, 24)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(10, 8, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(18, 14, 20)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.1 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[2]_out" - }, - "set": { - "type": "LessThan", - "upper": 137.99 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[3]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.042 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[4]_out" - }, - "set": { - "type": "LessThan", - "upper": 16.76 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[5]_out" - }, - "set": { - "type": "LessThan", - "upper": 10.35 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[6]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.32 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[7]_out" - }, - "set": { - "type": "LessThan", - "upper": 9.72 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[8]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.07 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[9]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.04 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[10]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[11]_out" - }, - "set": { - "type": "LessThan", - "upper": 2.93 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]" - }, - "set": { - "type": "LessThan", - "upper": 10.2926 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[2]" - }, - "set": { - "type": "LessThan", - "upper": 10.5531 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[3]" - }, - "set": { - "type": "LessThan", - "upper": 0.7854 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[4]" - }, - "set": { - "type": "LessThan", - "upper": 3.63 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[5]" - }, - "set": { - "type": "LessThan", - "upper": 8.74 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[6]" - }, - "set": { - "type": "LessThan", - "upper": 17.01 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[7]" - }, - "set": { - "type": "LessThan", - "upper": 1.25 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[8]" - }, - "set": { - "type": "LessThan", - "upper": 7.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[9]" - }, - "set": { - "type": "LessThan", - "upper": 11.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[10]" - }, - "set": { - "type": "LessThan", - "upper": 0.84 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[11]" - }, - "set": { - "type": "LessThan", - "upper": 3.24 - } - } - ] -} +{"name":"MathOptFormat Model","version":{"major":1,"minor":7},"variables":[{"name":"0_va[5]","primal_start":0.0},{"name":"0_va[16]","primal_start":0.0},{"name":"0_va[20]","primal_start":0.0},{"name":"0_va[12]","primal_start":0.0},{"name":"0_va[24]","primal_start":0.0},{"name":"0_va[28]","primal_start":0.0},{"name":"0_va[8]","primal_start":0.0},{"name":"0_va[17]","primal_start":0.0},{"name":"0_va[1]","primal_start":0.0},{"name":"0_va[23]","primal_start":0.0},{"name":"0_va[22]","primal_start":0.0},{"name":"0_va[19]","primal_start":0.0},{"name":"0_va[6]","primal_start":0.0},{"name":"0_va[11]","primal_start":0.0},{"name":"0_va[9]","primal_start":0.0},{"name":"0_va[14]","primal_start":0.0},{"name":"0_va[3]","primal_start":0.0},{"name":"0_va[7]","primal_start":0.0},{"name":"0_va[25]","primal_start":0.0},{"name":"0_va[4]","primal_start":0.0},{"name":"0_va[13]","primal_start":0.0},{"name":"0_va[15]","primal_start":0.0},{"name":"0_va[2]","primal_start":0.0},{"name":"0_va[27]","primal_start":0.0},{"name":"0_va[21]","primal_start":0.0},{"name":"0_va[26]","primal_start":0.0},{"name":"0_va[10]","primal_start":0.0},{"name":"0_va[18]","primal_start":0.0},{"name":"0_pg[5]","primal_start":0.0},{"name":"0_pg[16]","primal_start":0.0},{"name":"0_pg[20]","primal_start":0.0},{"name":"0_pg[12]","primal_start":0.0},{"name":"0_pg[24]","primal_start":0.0},{"name":"0_pg[28]","primal_start":0.0},{"name":"0_pg[8]","primal_start":0.0},{"name":"0_pg[17]","primal_start":0.0},{"name":"0_pg[30]","primal_start":0.0},{"name":"0_pg[1]","primal_start":0.0},{"name":"0_pg[23]","primal_start":0.0},{"name":"0_pg[32]","primal_start":0.0},{"name":"0_pg[22]","primal_start":0.0},{"name":"0_pg[6]","primal_start":0.0},{"name":"0_pg[19]","primal_start":0.0},{"name":"0_pg[11]","primal_start":0.0},{"name":"0_pg[31]","primal_start":0.0},{"name":"0_pg[9]","primal_start":0.0},{"name":"0_pg[14]","primal_start":0.0},{"name":"0_pg[3]","primal_start":0.0},{"name":"0_pg[29]","primal_start":0.0},{"name":"0_pg[33]","primal_start":0.0},{"name":"0_pg[25]","primal_start":0.0},{"name":"0_pg[7]","primal_start":0.0},{"name":"0_pg[34]","primal_start":0.0},{"name":"0_pg[4]","primal_start":0.0},{"name":"0_pg[13]","primal_start":0.0},{"name":"0_pg[15]","primal_start":0.0},{"name":"0_pg[2]","primal_start":0.0},{"name":"0_pg[27]","primal_start":0.0},{"name":"0_pg[21]","primal_start":0.0},{"name":"0_pg[26]","primal_start":0.0},{"name":"0_pg[10]","primal_start":0.0},{"name":"0_pg[18]","primal_start":0.0},{"name":"0_p[(5, 5, 6)]","primal_start":0.0},{"name":"0_p[(16, 13, 14)]","primal_start":0.0},{"name":"0_p[(20, 16, 17)]","primal_start":0.0},{"name":"0_p[(12, 9, 12)]","primal_start":0.0},{"name":"0_p[(24, 21, 22)]","primal_start":0.0},{"name":"0_p[(28, 25, 26)]","primal_start":0.0},{"name":"0_p[(8, 7, 8)]","primal_start":0.0},{"name":"0_p[(17, 14, 15)]","primal_start":0.0},{"name":"0_p[(30, 19, 28)]","primal_start":0.0},{"name":"0_p[(1, 2, 1)]","primal_start":0.0},{"name":"0_p[(23, 20, 21)]","primal_start":0.0},{"name":"0_p[(22, 16, 19)]","primal_start":0.0},{"name":"0_p[(19, 14, 16)]","primal_start":0.0},{"name":"0_p[(6, 5, 11)]","primal_start":0.0},{"name":"0_p[(11, 9, 10)]","primal_start":0.0},{"name":"0_p[(31, 19, 28)]","primal_start":0.0},{"name":"0_p[(9, 7, 10)]","primal_start":0.0},{"name":"0_p[(14, 11, 18)]","primal_start":0.0},{"name":"0_p[(3, 3, 4)]","primal_start":0.0},{"name":"0_p[(29, 17, 27)]","primal_start":0.0},{"name":"0_p[(7, 6, 7)]","primal_start":0.0},{"name":"0_p[(25, 22, 23)]","primal_start":0.0},{"name":"0_p[(4, 4, 5)]","primal_start":0.0},{"name":"0_p[(13, 9, 16)]","primal_start":0.0},{"name":"0_p[(15, 12, 13)]","primal_start":0.0},{"name":"0_p[(2, 2, 3)]","primal_start":0.0},{"name":"0_p[(27, 24, 25)]","primal_start":0.0},{"name":"0_p[(21, 18, 16)]","primal_start":0.0},{"name":"0_p[(26, 23, 24)]","primal_start":0.0},{"name":"0_p[(10, 8, 9)]","primal_start":0.0},{"name":"0_p[(18, 14, 20)]","primal_start":0.0},{"name":"reservoir[1]_in","primal_start":0.0},{"name":"reservoir[1]_out","primal_start":0.0},{"name":"reservoir[2]_in","primal_start":0.0},{"name":"reservoir[2]_out","primal_start":0.0},{"name":"reservoir[3]_in","primal_start":0.0},{"name":"reservoir[3]_out","primal_start":0.0},{"name":"reservoir[4]_in","primal_start":0.0},{"name":"reservoir[4]_out","primal_start":0.0},{"name":"reservoir[5]_in","primal_start":0.0},{"name":"reservoir[5]_out","primal_start":0.0},{"name":"reservoir[6]_in","primal_start":0.0},{"name":"reservoir[6]_out","primal_start":0.0},{"name":"reservoir[7]_in","primal_start":0.0},{"name":"reservoir[7]_out","primal_start":0.0},{"name":"reservoir[8]_in","primal_start":0.0},{"name":"reservoir[8]_out","primal_start":0.0},{"name":"reservoir[9]_in","primal_start":0.0},{"name":"reservoir[9]_out","primal_start":0.0},{"name":"reservoir[10]_in","primal_start":0.0},{"name":"reservoir[10]_out","primal_start":0.0},{"name":"reservoir[11]_in","primal_start":0.0},{"name":"reservoir[11]_out","primal_start":0.0},{"name":"min_volume_violation[1]","primal_start":0.0},{"name":"min_volume_violation[2]","primal_start":0.0},{"name":"min_volume_violation[3]","primal_start":0.0},{"name":"min_volume_violation[4]","primal_start":0.0},{"name":"min_volume_violation[5]","primal_start":0.0},{"name":"min_volume_violation[6]","primal_start":0.0},{"name":"min_volume_violation[7]","primal_start":0.0},{"name":"min_volume_violation[8]","primal_start":0.0},{"name":"min_volume_violation[9]","primal_start":0.0},{"name":"min_volume_violation[10]","primal_start":0.0},{"name":"min_volume_violation[11]","primal_start":0.0},{"name":"outflow[1]","primal_start":0.0},{"name":"outflow[2]","primal_start":0.0},{"name":"outflow[3]","primal_start":0.0},{"name":"outflow[4]","primal_start":0.0},{"name":"outflow[5]","primal_start":0.0},{"name":"outflow[6]","primal_start":0.0},{"name":"outflow[7]","primal_start":0.0},{"name":"outflow[8]","primal_start":0.0},{"name":"outflow[9]","primal_start":0.0},{"name":"outflow[10]","primal_start":0.0},{"name":"outflow[11]","primal_start":0.0},{"name":"spill[1]","primal_start":0.0},{"name":"spill[2]","primal_start":0.0},{"name":"spill[3]","primal_start":0.0},{"name":"spill[4]","primal_start":0.0},{"name":"spill[5]","primal_start":0.0},{"name":"spill[6]","primal_start":0.0},{"name":"spill[7]","primal_start":0.0},{"name":"spill[8]","primal_start":0.0},{"name":"spill[9]","primal_start":0.0},{"name":"spill[10]","primal_start":0.0},{"name":"spill[11]","primal_start":0.0},{"name":"min_outflow_violation[1]","primal_start":0.0},{"name":"min_outflow_violation[2]","primal_start":0.0},{"name":"min_outflow_violation[3]","primal_start":0.0},{"name":"min_outflow_violation[4]","primal_start":0.0},{"name":"min_outflow_violation[5]","primal_start":0.0},{"name":"min_outflow_violation[6]","primal_start":0.0},{"name":"min_outflow_violation[7]","primal_start":0.0},{"name":"min_outflow_violation[8]","primal_start":0.0},{"name":"min_outflow_violation[9]","primal_start":0.0},{"name":"min_outflow_violation[10]","primal_start":0.0},{"name":"min_outflow_violation[11]","primal_start":0.0},{"name":"inflow[1]","primal_start":0.0},{"name":"inflow[2]","primal_start":0.0},{"name":"inflow[3]","primal_start":0.0},{"name":"inflow[4]","primal_start":0.0},{"name":"inflow[5]","primal_start":0.0},{"name":"inflow[6]","primal_start":0.0},{"name":"inflow[7]","primal_start":0.0},{"name":"inflow[8]","primal_start":0.0},{"name":"inflow[9]","primal_start":0.0},{"name":"inflow[10]","primal_start":0.0},{"name":"inflow[11]","primal_start":0.0},{"name":"deficit[1]","primal_start":0.0},{"name":"deficit[2]","primal_start":0.0},{"name":"deficit[3]","primal_start":0.0},{"name":"deficit[4]","primal_start":0.0},{"name":"deficit[5]","primal_start":0.0},{"name":"deficit[6]","primal_start":0.0},{"name":"deficit[7]","primal_start":0.0},{"name":"deficit[8]","primal_start":0.0},{"name":"deficit[9]","primal_start":0.0},{"name":"deficit[10]","primal_start":0.0},{"name":"deficit[11]","primal_start":0.0},{"name":"deficit[12]","primal_start":0.0},{"name":"deficit[13]","primal_start":0.0},{"name":"deficit[14]","primal_start":0.0},{"name":"deficit[15]","primal_start":0.0},{"name":"deficit[16]","primal_start":0.0},{"name":"deficit[17]","primal_start":0.0},{"name":"deficit[18]","primal_start":0.0},{"name":"deficit[19]","primal_start":0.0},{"name":"deficit[20]","primal_start":0.0},{"name":"deficit[21]","primal_start":0.0},{"name":"deficit[22]","primal_start":0.0},{"name":"deficit[23]","primal_start":0.0},{"name":"deficit[24]","primal_start":0.0},{"name":"deficit[25]","primal_start":0.0},{"name":"deficit[26]","primal_start":0.0},{"name":"deficit[27]","primal_start":0.0},{"name":"deficit[28]","primal_start":0.0}],"objective":{"sense":"min","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":6000.0,"variable":"deficit[1]"},{"coefficient":6000.0,"variable":"deficit[2]"},{"coefficient":6000.0,"variable":"deficit[3]"},{"coefficient":6000.0,"variable":"deficit[4]"},{"coefficient":6000.0,"variable":"deficit[5]"},{"coefficient":6000.0,"variable":"deficit[6]"},{"coefficient":6000.0,"variable":"deficit[7]"},{"coefficient":6000.0,"variable":"deficit[8]"},{"coefficient":6000.0,"variable":"deficit[9]"},{"coefficient":6000.0,"variable":"deficit[10]"},{"coefficient":6000.0,"variable":"deficit[11]"},{"coefficient":6000.0,"variable":"deficit[12]"},{"coefficient":6000.0,"variable":"deficit[13]"},{"coefficient":6000.0,"variable":"deficit[14]"},{"coefficient":6000.0,"variable":"deficit[15]"},{"coefficient":6000.0,"variable":"deficit[16]"},{"coefficient":6000.0,"variable":"deficit[17]"},{"coefficient":6000.0,"variable":"deficit[18]"},{"coefficient":6000.0,"variable":"deficit[19]"},{"coefficient":6000.0,"variable":"deficit[20]"},{"coefficient":6000.0,"variable":"deficit[21]"},{"coefficient":6000.0,"variable":"deficit[22]"},{"coefficient":6000.0,"variable":"deficit[23]"},{"coefficient":6000.0,"variable":"deficit[24]"},{"coefficient":6000.0,"variable":"deficit[25]"},{"coefficient":6000.0,"variable":"deficit[26]"},{"coefficient":6000.0,"variable":"deficit[27]"},{"coefficient":6000.0,"variable":"deficit[28]"},{"coefficient":2268.0,"variable":"0_pg[5]"},{"coefficient":2059.0,"variable":"0_pg[16]"},{"coefficient":1780.0,"variable":"0_pg[20]"},{"coefficient":1576.0,"variable":"0_pg[12]"},{"coefficient":10.0,"variable":"0_pg[24]"},{"coefficient":10.0,"variable":"0_pg[28]"},{"coefficient":1754.0,"variable":"0_pg[8]"},{"coefficient":2059.0,"variable":"0_pg[17]"},{"coefficient":10.0,"variable":"0_pg[30]"},{"coefficient":1918.0,"variable":"0_pg[1]"},{"coefficient":4244.0,"variable":"0_pg[23]"},{"coefficient":10.0,"variable":"0_pg[32]"},{"coefficient":1517.0,"variable":"0_pg[22]"},{"coefficient":2131.0,"variable":"0_pg[6]"},{"coefficient":1780.0,"variable":"0_pg[19]"},{"coefficient":1576.0,"variable":"0_pg[11]"},{"coefficient":10.0,"variable":"0_pg[31]"},{"coefficient":1576.0,"variable":"0_pg[9]"},{"coefficient":1404.0,"variable":"0_pg[14]"},{"coefficient":2184.0,"variable":"0_pg[3]"},{"coefficient":10.0,"variable":"0_pg[29]"},{"coefficient":10.0,"variable":"0_pg[33]"},{"coefficient":10.0,"variable":"0_pg[25]"},{"coefficient":1822.0,"variable":"0_pg[7]"},{"coefficient":10.0,"variable":"0_pg[34]"},{"coefficient":2179.0,"variable":"0_pg[4]"},{"coefficient":1404.0,"variable":"0_pg[13]"},{"coefficient":2077.0,"variable":"0_pg[15]"},{"coefficient":2120.0,"variable":"0_pg[2]"},{"coefficient":10.0,"variable":"0_pg[27]"},{"coefficient":1598.0,"variable":"0_pg[21]"},{"coefficient":10.0,"variable":"0_pg[26]"},{"coefficient":1576.0,"variable":"0_pg[10]"},{"coefficient":2059.0,"variable":"0_pg[18]"}],"constant":0.0}},"constraints":[{"name":"c1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[1]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(5, 5, 6)]"},{"coefficient":1.0,"variable":"0_p[(6, 5, 11)]"},{"coefficient":-1.0,"variable":"0_p[(4, 4, 5)]"},{"coefficient":-1.0,"variable":"deficit[5]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c3","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(20, 16, 17)]"},{"coefficient":1.0,"variable":"0_p[(22, 16, 19)]"},{"coefficient":-1.0,"variable":"0_p[(19, 14, 16)]"},{"coefficient":-1.0,"variable":"0_p[(13, 9, 16)]"},{"coefficient":-1.0,"variable":"0_p[(21, 18, 16)]"},{"coefficient":-1.0,"variable":"deficit[16]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.21439096103324617}},{"name":"c4","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(23, 20, 21)]"},{"coefficient":-1.0,"variable":"0_p[(18, 14, 20)]"},{"coefficient":-1.0,"variable":"deficit[20]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.0015565421870758504}},{"name":"c5","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_p[(12, 9, 12)]"},{"coefficient":1.0,"variable":"0_p[(15, 12, 13)]"},{"coefficient":-1.0,"variable":"deficit[12]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.05738794110411041}},{"name":"c6","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(27, 24, 25)]"},{"coefficient":-1.0,"variable":"0_p[(26, 23, 24)]"},{"coefficient":-1.0,"variable":"deficit[24]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.01804043447630477}},{"name":"c7","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[28]"},{"coefficient":-1.0,"variable":"0_pg[30]"},{"coefficient":-1.0,"variable":"0_pg[29]"},{"coefficient":-1.0,"variable":"0_p[(30, 19, 28)]"},{"coefficient":-1.0,"variable":"0_p[(31, 19, 28)]"},{"coefficient":-1.0,"variable":"deficit[28]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c8","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[25]"},{"coefficient":-1.0,"variable":"0_p[(8, 7, 8)]"},{"coefficient":1.0,"variable":"0_p[(10, 8, 9)]"},{"coefficient":-1.0,"variable":"deficit[8]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c9","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_p[(20, 16, 17)]"},{"coefficient":1.0,"variable":"0_p[(29, 17, 27)]"},{"coefficient":-1.0,"variable":"deficit[17]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.267753330934522}},{"name":"c10","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[5]"},{"coefficient":-1.0,"variable":"0_pg[8]"},{"coefficient":-1.0,"variable":"0_pg[1]"},{"coefficient":-1.0,"variable":"0_pg[6]"},{"coefficient":-1.0,"variable":"0_pg[9]"},{"coefficient":-1.0,"variable":"0_pg[3]"},{"coefficient":-1.0,"variable":"0_pg[7]"},{"coefficient":-1.0,"variable":"0_pg[4]"},{"coefficient":-1.0,"variable":"0_pg[2]"},{"coefficient":-1.0,"variable":"0_pg[10]"},{"coefficient":-1.0,"variable":"0_p[(1, 2, 1)]"},{"coefficient":-1.0,"variable":"deficit[1]"}],"constant":0.0},"set":{"type":"EqualTo","value":-1.6075543555612704}},{"name":"c11","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[21]"},{"coefficient":-1.0,"variable":"0_p[(25, 22, 23)]"},{"coefficient":1.0,"variable":"0_p[(26, 23, 24)]"},{"coefficient":-1.0,"variable":"deficit[23]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.0004825663866386638}},{"name":"c12","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[34]"},{"coefficient":-1.0,"variable":"0_p[(24, 21, 22)]"},{"coefficient":1.0,"variable":"0_p[(25, 22, 23)]"},{"coefficient":-1.0,"variable":"deficit[22]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.12074817048704867}},{"name":"c13","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[20]"},{"coefficient":-1.0,"variable":"0_pg[32]"},{"coefficient":-1.0,"variable":"0_pg[19]"},{"coefficient":-1.0,"variable":"0_pg[31]"},{"coefficient":-1.0,"variable":"0_pg[33]"},{"coefficient":1.0,"variable":"0_p[(30, 19, 28)]"},{"coefficient":-1.0,"variable":"0_p[(22, 16, 19)]"},{"coefficient":1.0,"variable":"0_p[(31, 19, 28)]"},{"coefficient":-1.0,"variable":"deficit[19]"}],"constant":0.0},"set":{"type":"EqualTo","value":-1.4735118986170044}},{"name":"c14","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_p[(5, 5, 6)]"},{"coefficient":1.0,"variable":"0_p[(7, 6, 7)]"},{"coefficient":-1.0,"variable":"deficit[6]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c15","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_p[(6, 5, 11)]"},{"coefficient":1.0,"variable":"0_p[(14, 11, 18)]"},{"coefficient":-1.0,"variable":"deficit[11]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c16","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[16]"},{"coefficient":-1.0,"variable":"0_pg[17]"},{"coefficient":-1.0,"variable":"0_pg[15]"},{"coefficient":-1.0,"variable":"0_pg[18]"},{"coefficient":1.0,"variable":"0_p[(12, 9, 12)]"},{"coefficient":1.0,"variable":"0_p[(11, 9, 10)]"},{"coefficient":1.0,"variable":"0_p[(13, 9, 16)]"},{"coefficient":-1.0,"variable":"0_p[(10, 8, 9)]"},{"coefficient":-1.0,"variable":"deficit[9]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.21593913974111698}},{"name":"c17","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_p[(16, 13, 14)]"},{"coefficient":1.0,"variable":"0_p[(17, 14, 15)]"},{"coefficient":1.0,"variable":"0_p[(19, 14, 16)]"},{"coefficient":1.0,"variable":"0_p[(18, 14, 20)]"},{"coefficient":-1.0,"variable":"deficit[14]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c18","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[12]"},{"coefficient":-1.0,"variable":"0_pg[11]"},{"coefficient":-1.0,"variable":"0_pg[14]"},{"coefficient":-1.0,"variable":"0_pg[13]"},{"coefficient":1.0,"variable":"0_p[(3, 3, 4)]"},{"coefficient":-1.0,"variable":"0_p[(2, 2, 3)]"},{"coefficient":-1.0,"variable":"deficit[3]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c19","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[24]"},{"coefficient":1.0,"variable":"0_p[(8, 7, 8)]"},{"coefficient":1.0,"variable":"0_p[(9, 7, 10)]"},{"coefficient":-1.0,"variable":"0_p[(7, 6, 7)]"},{"coefficient":-1.0,"variable":"deficit[7]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c20","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(28, 25, 26)]"},{"coefficient":-1.0,"variable":"0_p[(27, 24, 25)]"},{"coefficient":-1.0,"variable":"deficit[25]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.0004825663866386638}},{"name":"c21","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_p[(3, 3, 4)]"},{"coefficient":1.0,"variable":"0_p[(4, 4, 5)]"},{"coefficient":-1.0,"variable":"deficit[4]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.02040724338005229}},{"name":"c22","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(16, 13, 14)]"},{"coefficient":-1.0,"variable":"0_p[(15, 12, 13)]"},{"coefficient":-1.0,"variable":"deficit[13]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.0004825663866386638}},{"name":"c23","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_p[(17, 14, 15)]"},{"coefficient":-1.0,"variable":"deficit[15]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.10015864047547611}},{"name":"c24","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(1, 2, 1)]"},{"coefficient":1.0,"variable":"0_p[(2, 2, 3)]"},{"coefficient":-1.0,"variable":"deficit[2]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c25","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[27]"},{"coefficient":-1.0,"variable":"0_p[(29, 17, 27)]"},{"coefficient":-1.0,"variable":"deficit[27]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c26","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(24, 21, 22)]"},{"coefficient":-1.0,"variable":"0_p[(23, 20, 21)]"},{"coefficient":-1.0,"variable":"deficit[21]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c27","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[23]"},{"coefficient":-1.0,"variable":"0_pg[22]"},{"coefficient":-1.0,"variable":"0_p[(28, 25, 26)]"},{"coefficient":-1.0,"variable":"deficit[26]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.1700922829782978}},{"name":"c28","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[26]"},{"coefficient":-1.0,"variable":"0_p[(11, 9, 10)]"},{"coefficient":-1.0,"variable":"0_p[(9, 7, 10)]"},{"coefficient":-1.0,"variable":"deficit[10]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.5563327884359863}},{"name":"c29","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_p[(14, 11, 18)]"},{"coefficient":1.0,"variable":"0_p[(21, 18, 16)]"},{"coefficient":-1.0,"variable":"deficit[18]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c30","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-12.485777918589607,"variable":"0_va[5]"},{"coefficient":12.485777918589607,"variable":"0_va[6]"},{"coefficient":1.0,"variable":"0_p[(5, 5, 6)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c31","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":6.795713842466891,"variable":"0_va[14]"},{"coefficient":-6.795713842466891,"variable":"0_va[13]"},{"coefficient":1.0,"variable":"0_p[(16, 13, 14)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c32","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-10.149298248521102,"variable":"0_va[16]"},{"coefficient":10.149298248521102,"variable":"0_va[17]"},{"coefficient":1.0,"variable":"0_p[(20, 16, 17)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c33","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":6.481250938450924,"variable":"0_va[12]"},{"coefficient":-6.481250938450924,"variable":"0_va[9]"},{"coefficient":1.0,"variable":"0_p[(12, 9, 12)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c34","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":4.2328983731321435,"variable":"0_va[22]"},{"coefficient":-4.2328983731321435,"variable":"0_va[21]"},{"coefficient":1.0,"variable":"0_p[(24, 21, 22)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c35","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-2.091029561081878,"variable":"0_va[25]"},{"coefficient":2.091029561081878,"variable":"0_va[26]"},{"coefficient":1.0,"variable":"0_p[(28, 25, 26)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c36","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":45.39453875906154,"variable":"0_va[8]"},{"coefficient":-45.39453875906154,"variable":"0_va[7]"},{"coefficient":1.0,"variable":"0_p[(8, 7, 8)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c37","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-19.8968547052082,"variable":"0_va[14]"},{"coefficient":19.8968547052082,"variable":"0_va[15]"},{"coefficient":1.0,"variable":"0_p[(17, 14, 15)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c38","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":9.121944633618186,"variable":"0_va[28]"},{"coefficient":-9.121944633618186,"variable":"0_va[19]"},{"coefficient":1.0,"variable":"0_p[(30, 19, 28)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c39","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":9.363115118052471,"variable":"0_va[1]"},{"coefficient":-9.363115118052471,"variable":"0_va[2]"},{"coefficient":1.0,"variable":"0_p[(1, 2, 1)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c40","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-3.33399327650884,"variable":"0_va[20]"},{"coefficient":3.33399327650884,"variable":"0_va[21]"},{"coefficient":1.0,"variable":"0_p[(23, 20, 21)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c41","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-2.8140484527509644,"variable":"0_va[16]"},{"coefficient":2.8140484527509644,"variable":"0_va[19]"},{"coefficient":1.0,"variable":"0_p[(22, 16, 19)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c42","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":3.667991302391842,"variable":"0_va[16]"},{"coefficient":-3.667991302391842,"variable":"0_va[14]"},{"coefficient":1.0,"variable":"0_p[(19, 14, 16)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c43","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-20.88296190751831,"variable":"0_va[5]"},{"coefficient":20.88296190751831,"variable":"0_va[11]"},{"coefficient":1.0,"variable":"0_p[(6, 5, 11)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c44","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-52.44594387363901,"variable":"0_va[9]"},{"coefficient":52.44594387363901,"variable":"0_va[10]"},{"coefficient":1.0,"variable":"0_p[(11, 9, 10)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c45","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":5.498037005409949,"variable":"0_va[28]"},{"coefficient":-5.498037005409949,"variable":"0_va[19]"},{"coefficient":1.0,"variable":"0_p[(31, 19, 28)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c46","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-6.467289330533839,"variable":"0_va[7]"},{"coefficient":6.467289330533839,"variable":"0_va[10]"},{"coefficient":1.0,"variable":"0_p[(9, 7, 10)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c47","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-8.698708713000553,"variable":"0_va[11]"},{"coefficient":8.698708713000553,"variable":"0_va[18]"},{"coefficient":1.0,"variable":"0_p[(14, 11, 18)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c48","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-17.010777436904807,"variable":"0_va[3]"},{"coefficient":17.010777436904807,"variable":"0_va[4]"},{"coefficient":1.0,"variable":"0_p[(3, 3, 4)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c49","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.6861921183958626,"variable":"0_va[17]"},{"coefficient":1.6861921183958626,"variable":"0_va[27]"},{"coefficient":1.0,"variable":"0_p[(29, 17, 27)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c50","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-31.512256609281188,"variable":"0_va[6]"},{"coefficient":31.512256609281188,"variable":"0_va[7]"},{"coefficient":1.0,"variable":"0_p[(7, 6, 7)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c51","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":8.939086077602251,"variable":"0_va[23]"},{"coefficient":-8.939086077602251,"variable":"0_va[22]"},{"coefficient":1.0,"variable":"0_p[(25, 22, 23)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c52","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":16.36003009370084,"variable":"0_va[5]"},{"coefficient":-16.36003009370084,"variable":"0_va[4]"},{"coefficient":1.0,"variable":"0_p[(4, 4, 5)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c53","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.8998888915041532,"variable":"0_va[16]"},{"coefficient":-1.8998888915041532,"variable":"0_va[9]"},{"coefficient":1.0,"variable":"0_p[(13, 9, 16)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c54","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-7.029547007720768,"variable":"0_va[12]"},{"coefficient":7.029547007720768,"variable":"0_va[13]"},{"coefficient":1.0,"variable":"0_p[(15, 12, 13)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c55","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":7.165952433825185,"variable":"0_va[3]"},{"coefficient":-7.165952433825185,"variable":"0_va[2]"},{"coefficient":1.0,"variable":"0_p[(2, 2, 3)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c56","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-2.868957761798156,"variable":"0_va[24]"},{"coefficient":2.868957761798156,"variable":"0_va[25]"},{"coefficient":1.0,"variable":"0_p[(27, 24, 25)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c57","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":11.73125512037617,"variable":"0_va[16]"},{"coefficient":-11.73125512037617,"variable":"0_va[18]"},{"coefficient":1.0,"variable":"0_p[(21, 18, 16)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c58","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":5.604798539074481,"variable":"0_va[24]"},{"coefficient":-5.604798539074481,"variable":"0_va[23]"},{"coefficient":1.0,"variable":"0_p[(26, 23, 24)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c59","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-6.776372942488066,"variable":"0_va[8]"},{"coefficient":6.776372942488066,"variable":"0_va[9]"},{"coefficient":1.0,"variable":"0_p[(10, 8, 9)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c60","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":2.875699016068521,"variable":"0_va[20]"},{"coefficient":-2.875699016068521,"variable":"0_va[14]"},{"coefficient":1.0,"variable":"0_p[(18, 14, 20)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[1]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[1]_in"},{"coefficient":1.0,"variable":"reservoir[1]_out"},{"coefficient":0.6048,"variable":"outflow[1]"},{"coefficient":-0.6048,"variable":"outflow[2]"},{"coefficient":1.0,"variable":"spill[1]"},{"coefficient":-0.6048,"variable":"inflow[1]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[2]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[2]_in"},{"coefficient":1.0,"variable":"reservoir[2]_out"},{"coefficient":0.6048,"variable":"outflow[2]"},{"coefficient":1.0,"variable":"spill[2]"},{"coefficient":-0.6048,"variable":"inflow[2]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[3]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[3]_in"},{"coefficient":1.0,"variable":"reservoir[3]_out"},{"coefficient":0.6048,"variable":"outflow[3]"},{"coefficient":1.0,"variable":"spill[3]"},{"coefficient":-0.6048,"variable":"inflow[3]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[4]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[4]_in"},{"coefficient":1.0,"variable":"reservoir[4]_out"},{"coefficient":0.6048,"variable":"outflow[4]"},{"coefficient":1.0,"variable":"spill[4]"},{"coefficient":-0.6048,"variable":"inflow[4]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[5]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[5]_in"},{"coefficient":1.0,"variable":"reservoir[5]_out"},{"coefficient":0.6048,"variable":"outflow[5]"},{"coefficient":1.0,"variable":"spill[5]"},{"coefficient":-0.6048,"variable":"inflow[5]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[6]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[6]_in"},{"coefficient":1.0,"variable":"reservoir[6]_out"},{"coefficient":-0.6048,"variable":"outflow[5]"},{"coefficient":0.6048,"variable":"outflow[6]"},{"coefficient":-1.0,"variable":"spill[5]"},{"coefficient":1.0,"variable":"spill[6]"},{"coefficient":-0.6048,"variable":"inflow[6]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[7]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[7]_in"},{"coefficient":1.0,"variable":"reservoir[7]_out"},{"coefficient":0.6048,"variable":"outflow[7]"},{"coefficient":1.0,"variable":"spill[7]"},{"coefficient":-0.6048,"variable":"inflow[7]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[8]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[8]_in"},{"coefficient":1.0,"variable":"reservoir[8]_out"},{"coefficient":0.6048,"variable":"outflow[8]"},{"coefficient":1.0,"variable":"spill[8]"},{"coefficient":-0.6048,"variable":"inflow[8]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[9]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[9]_in"},{"coefficient":1.0,"variable":"reservoir[9]_out"},{"coefficient":-0.6048,"variable":"outflow[8]"},{"coefficient":0.6048,"variable":"outflow[9]"},{"coefficient":-1.0,"variable":"spill[8]"},{"coefficient":1.0,"variable":"spill[9]"},{"coefficient":-0.6048,"variable":"inflow[9]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[10]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[10]_in"},{"coefficient":1.0,"variable":"reservoir[10]_out"},{"coefficient":0.6048,"variable":"outflow[10]"},{"coefficient":1.0,"variable":"spill[10]"},{"coefficient":-0.6048,"variable":"inflow[10]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[11]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[11]_in"},{"coefficient":1.0,"variable":"reservoir[11]_out"},{"coefficient":0.6048,"variable":"outflow[11]"},{"coefficient":1.0,"variable":"spill[11]"},{"coefficient":-0.6048,"variable":"inflow[11]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[1]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[24]"},{"coefficient":-6.9953,"variable":"outflow[1]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[2]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[25]"},{"coefficient":-5.117,"variable":"outflow[2]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[3]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[26]"},{"coefficient":-9.677,"variable":"outflow[3]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[4]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[27]"},{"coefficient":-5.06,"variable":"outflow[4]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[5]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[28]"},{"coefficient":-8.11,"variable":"outflow[5]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[6]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[29]"},{"coefficient":-6.35,"variable":"outflow[6]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[7]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[30]"},{"coefficient":-3.2,"variable":"outflow[7]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[8]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[31]"},{"coefficient":-4.81,"variable":"outflow[8]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[9]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[32]"},{"coefficient":-4.47,"variable":"outflow[9]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[10]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[33]"},{"coefficient":-1.2,"variable":"outflow[10]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[11]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[34]"},{"coefficient":-2.5,"variable":"outflow[11]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"min_volume_violation_bound[1]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[1]_out"},{"coefficient":1.0,"variable":"min_volume_violation[1]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_volume_violation_bound[2]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[2]_out"},{"coefficient":1.0,"variable":"min_volume_violation[2]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_volume_violation_bound[3]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[3]_out"},{"coefficient":1.0,"variable":"min_volume_violation[3]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_volume_violation_bound[4]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[4]_out"},{"coefficient":1.0,"variable":"min_volume_violation[4]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_volume_violation_bound[5]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[5]_out"},{"coefficient":1.0,"variable":"min_volume_violation[5]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_volume_violation_bound[6]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[6]_out"},{"coefficient":1.0,"variable":"min_volume_violation[6]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_volume_violation_bound[7]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[7]_out"},{"coefficient":1.0,"variable":"min_volume_violation[7]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_volume_violation_bound[8]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[8]_out"},{"coefficient":1.0,"variable":"min_volume_violation[8]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_volume_violation_bound[9]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[9]_out"},{"coefficient":1.0,"variable":"min_volume_violation[9]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_volume_violation_bound[10]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[10]_out"},{"coefficient":1.0,"variable":"min_volume_violation[10]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_volume_violation_bound[11]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[11]_out"},{"coefficient":1.0,"variable":"min_volume_violation[11]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[1]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[1]"},{"coefficient":1.0,"variable":"min_outflow_violation[1]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[2]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[2]"},{"coefficient":1.0,"variable":"min_outflow_violation[2]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[3]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[3]"},{"coefficient":1.0,"variable":"min_outflow_violation[3]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[4]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[4]"},{"coefficient":1.0,"variable":"min_outflow_violation[4]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[5]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[5]"},{"coefficient":1.0,"variable":"min_outflow_violation[5]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[6]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[6]"},{"coefficient":1.0,"variable":"min_outflow_violation[6]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[7]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[7]"},{"coefficient":1.0,"variable":"min_outflow_violation[7]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[8]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[8]"},{"coefficient":1.0,"variable":"min_outflow_violation[8]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[9]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[9]"},{"coefficient":1.0,"variable":"min_outflow_violation[9]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[10]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[10]"},{"coefficient":1.0,"variable":"min_outflow_violation[10]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[11]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[11]"},{"coefficient":1.0,"variable":"min_outflow_violation[11]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c1_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[5]"},{"coefficient":-1.0,"variable":"0_va[6]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c2_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_va[14]"},{"coefficient":1.0,"variable":"0_va[13]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c3_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[16]"},{"coefficient":-1.0,"variable":"0_va[17]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c4_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_va[12]"},{"coefficient":1.0,"variable":"0_va[9]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c5_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_va[22]"},{"coefficient":1.0,"variable":"0_va[21]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c6_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[25]"},{"coefficient":-1.0,"variable":"0_va[26]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c7_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_va[8]"},{"coefficient":1.0,"variable":"0_va[7]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c8_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[14]"},{"coefficient":-1.0,"variable":"0_va[15]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c9_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_va[28]"},{"coefficient":1.0,"variable":"0_va[19]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c10_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_va[1]"},{"coefficient":1.0,"variable":"0_va[2]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c11_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[20]"},{"coefficient":-1.0,"variable":"0_va[21]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c12_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[16]"},{"coefficient":-1.0,"variable":"0_va[19]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c13_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_va[16]"},{"coefficient":1.0,"variable":"0_va[14]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c14_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[5]"},{"coefficient":-1.0,"variable":"0_va[11]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c15_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[9]"},{"coefficient":-1.0,"variable":"0_va[10]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c16_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[7]"},{"coefficient":-1.0,"variable":"0_va[10]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c17_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[11]"},{"coefficient":-1.0,"variable":"0_va[18]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c18_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[3]"},{"coefficient":-1.0,"variable":"0_va[4]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c19_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[17]"},{"coefficient":-1.0,"variable":"0_va[27]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c20_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[6]"},{"coefficient":-1.0,"variable":"0_va[7]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c21_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_va[23]"},{"coefficient":1.0,"variable":"0_va[22]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c22_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_va[5]"},{"coefficient":1.0,"variable":"0_va[4]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c23_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_va[16]"},{"coefficient":1.0,"variable":"0_va[9]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c24_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[12]"},{"coefficient":-1.0,"variable":"0_va[13]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c25_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_va[3]"},{"coefficient":1.0,"variable":"0_va[2]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c26_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[24]"},{"coefficient":-1.0,"variable":"0_va[25]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c27_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_va[16]"},{"coefficient":1.0,"variable":"0_va[18]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c28_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_va[24]"},{"coefficient":1.0,"variable":"0_va[23]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c29_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_va[8]"},{"coefficient":-1.0,"variable":"0_va[9]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"name":"c30_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_va[20]"},{"coefficient":1.0,"variable":"0_va[14]"}],"constant":0.0},"set":{"type":"Interval","lower":-1.0472,"upper":1.0472}},{"function":{"type":"Variable","name":"reservoir[1]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"reservoir[2]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"reservoir[3]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"reservoir[4]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"reservoir[5]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"reservoir[6]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"reservoir[7]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"reservoir[8]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"reservoir[9]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"reservoir[10]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"reservoir[11]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"inflow[1]"},"set":{"type":"EqualTo","value":0.9398527488038416}},{"function":{"type":"Variable","name":"inflow[2]"},"set":{"type":"EqualTo","value":5.882002148039282}},{"function":{"type":"Variable","name":"inflow[3]"},"set":{"type":"EqualTo","value":0.2000144671649994}},{"function":{"type":"Variable","name":"inflow[4]"},"set":{"type":"EqualTo","value":3.9469358129786256}},{"function":{"type":"Variable","name":"inflow[5]"},"set":{"type":"EqualTo","value":6.211844156821933}},{"function":{"type":"Variable","name":"inflow[6]"},"set":{"type":"EqualTo","value":10.23842397764487}},{"function":{"type":"Variable","name":"inflow[7]"},"set":{"type":"EqualTo","value":0.1869794681093533}},{"function":{"type":"Variable","name":"inflow[8]"},"set":{"type":"EqualTo","value":10.477704945568126}},{"function":{"type":"Variable","name":"inflow[9]"},"set":{"type":"EqualTo","value":8.449733976255288}},{"function":{"type":"Variable","name":"inflow[10]"},"set":{"type":"EqualTo","value":1.4824946743419087}},{"function":{"type":"Variable","name":"inflow[11]"},"set":{"type":"EqualTo","value":3.37887731734589}},{"function":{"type":"Variable","name":"0_pg[5]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[16]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[20]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[12]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[24]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[28]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[8]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[17]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[30]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[1]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[23]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[32]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[22]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[6]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[19]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[11]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[31]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[9]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[14]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[3]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[29]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[33]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[25]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[7]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[34]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[4]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[13]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[15]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[2]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[27]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[21]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[26]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[10]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[18]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_p[(5, 5, 6)]"},"set":{"type":"GreaterThan","lower":-0.7}},{"function":{"type":"Variable","name":"0_p[(16, 13, 14)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(20, 16, 17)]"},"set":{"type":"GreaterThan","lower":-0.25}},{"function":{"type":"Variable","name":"0_p[(12, 9, 12)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(24, 21, 22)]"},"set":{"type":"GreaterThan","lower":-0.25}},{"function":{"type":"Variable","name":"0_p[(28, 25, 26)]"},"set":{"type":"GreaterThan","lower":-0.13}},{"function":{"type":"Variable","name":"0_p[(8, 7, 8)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(17, 14, 15)]"},"set":{"type":"GreaterThan","lower":-0.5}},{"function":{"type":"Variable","name":"0_p[(30, 19, 28)]"},"set":{"type":"GreaterThan","lower":-1.0}},{"function":{"type":"Variable","name":"0_p[(1, 2, 1)]"},"set":{"type":"GreaterThan","lower":-0.7}},{"function":{"type":"Variable","name":"0_p[(23, 20, 21)]"},"set":{"type":"GreaterThan","lower":-0.47}},{"function":{"type":"Variable","name":"0_p[(22, 16, 19)]"},"set":{"type":"GreaterThan","lower":-1.06}},{"function":{"type":"Variable","name":"0_p[(19, 14, 16)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(6, 5, 11)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_p[(11, 9, 10)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(31, 19, 28)]"},"set":{"type":"GreaterThan","lower":-1.0}},{"function":{"type":"Variable","name":"0_p[(9, 7, 10)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(14, 11, 18)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_p[(3, 3, 4)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_p[(29, 17, 27)]"},"set":{"type":"GreaterThan","lower":-2.0}},{"function":{"type":"Variable","name":"0_p[(7, 6, 7)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(25, 22, 23)]"},"set":{"type":"GreaterThan","lower":-0.33}},{"function":{"type":"Variable","name":"0_p[(4, 4, 5)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_p[(13, 9, 16)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(15, 12, 13)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(2, 2, 3)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_p[(27, 24, 25)]"},"set":{"type":"GreaterThan","lower":-0.13}},{"function":{"type":"Variable","name":"0_p[(21, 18, 16)]"},"set":{"type":"GreaterThan","lower":-1.0}},{"function":{"type":"Variable","name":"0_p[(26, 23, 24)]"},"set":{"type":"GreaterThan","lower":-0.13}},{"function":{"type":"Variable","name":"0_p[(10, 8, 9)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(18, 14, 20)]"},"set":{"type":"GreaterThan","lower":-0.47}},{"function":{"type":"Variable","name":"reservoir[1]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"reservoir[2]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"reservoir[3]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"reservoir[4]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"reservoir[5]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"reservoir[6]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"reservoir[7]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"reservoir[8]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"reservoir[9]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"reservoir[10]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"reservoir[11]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[1]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[2]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[3]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[4]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[5]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[6]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[7]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[8]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[9]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[10]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[11]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[1]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[2]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[3]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[4]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[5]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[6]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[7]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[8]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[9]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[10]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[11]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[1]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[2]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[3]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[4]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[5]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[6]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[7]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[8]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[9]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[10]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[11]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[1]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[2]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[3]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[4]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[5]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[6]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[7]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[8]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[9]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[10]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[11]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[1]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[2]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[3]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[4]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[5]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[6]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[7]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[8]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[9]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[10]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[11]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[12]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[13]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[14]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[15]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[16]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[17]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[18]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[19]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[20]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[21]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[22]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[23]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[24]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[25]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[26]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[27]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[28]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[5]"},"set":{"type":"LessThan","upper":0.153}},{"function":{"type":"Variable","name":"0_pg[16]"},"set":{"type":"LessThan","upper":0.149}},{"function":{"type":"Variable","name":"0_pg[20]"},"set":{"type":"LessThan","upper":0.07339999999999999}},{"function":{"type":"Variable","name":"0_pg[12]"},"set":{"type":"LessThan","upper":0.3381}},{"function":{"type":"Variable","name":"0_pg[24]"},"set":{"type":"LessThan","upper":0.72}},{"function":{"type":"Variable","name":"0_pg[28]"},"set":{"type":"LessThan","upper":0.7090000000000001}},{"function":{"type":"Variable","name":"0_pg[8]"},"set":{"type":"LessThan","upper":0.1888}},{"function":{"type":"Variable","name":"0_pg[17]"},"set":{"type":"LessThan","upper":0.149}},{"function":{"type":"Variable","name":"0_pg[30]"},"set":{"type":"LessThan","upper":0.04}},{"function":{"type":"Variable","name":"0_pg[1]"},"set":{"type":"LessThan","upper":0.1826}},{"function":{"type":"Variable","name":"0_pg[23]"},"set":{"type":"LessThan","upper":0.10800000000000001}},{"function":{"type":"Variable","name":"0_pg[32]"},"set":{"type":"LessThan","upper":0.4917}},{"function":{"type":"Variable","name":"0_pg[22]"},"set":{"type":"LessThan","upper":0.1494}},{"function":{"type":"Variable","name":"0_pg[6]"},"set":{"type":"LessThan","upper":0.1696}},{"function":{"type":"Variable","name":"0_pg[19]"},"set":{"type":"LessThan","upper":0.07339999999999999}},{"function":{"type":"Variable","name":"0_pg[11]"},"set":{"type":"LessThan","upper":0.3381}},{"function":{"type":"Variable","name":"0_pg[31]"},"set":{"type":"LessThan","upper":0.3367}},{"function":{"type":"Variable","name":"0_pg[9]"},"set":{"type":"LessThan","upper":0.5175}},{"function":{"type":"Variable","name":"0_pg[14]"},"set":{"type":"LessThan","upper":0.4497}},{"function":{"type":"Variable","name":"0_pg[3]"},"set":{"type":"LessThan","upper":0.1523}},{"function":{"type":"Variable","name":"0_pg[29]"},"set":{"type":"LessThan","upper":1.08}},{"function":{"type":"Variable","name":"0_pg[33]"},"set":{"type":"LessThan","upper":0.0101}},{"function":{"type":"Variable","name":"0_pg[25]"},"set":{"type":"LessThan","upper":0.54}},{"function":{"type":"Variable","name":"0_pg[7]"},"set":{"type":"LessThan","upper":0.1757}},{"function":{"type":"Variable","name":"0_pg[34]"},"set":{"type":"LessThan","upper":0.081}},{"function":{"type":"Variable","name":"0_pg[4]"},"set":{"type":"LessThan","upper":0.1623}},{"function":{"type":"Variable","name":"0_pg[13]"},"set":{"type":"LessThan","upper":0.4497}},{"function":{"type":"Variable","name":"0_pg[15]"},"set":{"type":"LessThan","upper":0.1483}},{"function":{"type":"Variable","name":"0_pg[2]"},"set":{"type":"LessThan","upper":0.1593}},{"function":{"type":"Variable","name":"0_pg[27]"},"set":{"type":"LessThan","upper":0.184}},{"function":{"type":"Variable","name":"0_pg[21]"},"set":{"type":"LessThan","upper":0.1134}},{"function":{"type":"Variable","name":"0_pg[26]"},"set":{"type":"LessThan","upper":0.076}},{"function":{"type":"Variable","name":"0_pg[10]"},"set":{"type":"LessThan","upper":0.5175}},{"function":{"type":"Variable","name":"0_pg[18]"},"set":{"type":"LessThan","upper":0.149}},{"function":{"type":"Variable","name":"0_p[(5, 5, 6)]"},"set":{"type":"LessThan","upper":0.7}},{"function":{"type":"Variable","name":"0_p[(16, 13, 14)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(20, 16, 17)]"},"set":{"type":"LessThan","upper":0.25}},{"function":{"type":"Variable","name":"0_p[(12, 9, 12)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(24, 21, 22)]"},"set":{"type":"LessThan","upper":0.25}},{"function":{"type":"Variable","name":"0_p[(28, 25, 26)]"},"set":{"type":"LessThan","upper":0.13}},{"function":{"type":"Variable","name":"0_p[(8, 7, 8)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(17, 14, 15)]"},"set":{"type":"LessThan","upper":0.5}},{"function":{"type":"Variable","name":"0_p[(30, 19, 28)]"},"set":{"type":"LessThan","upper":1.0}},{"function":{"type":"Variable","name":"0_p[(1, 2, 1)]"},"set":{"type":"LessThan","upper":0.7}},{"function":{"type":"Variable","name":"0_p[(23, 20, 21)]"},"set":{"type":"LessThan","upper":0.47}},{"function":{"type":"Variable","name":"0_p[(22, 16, 19)]"},"set":{"type":"LessThan","upper":1.06}},{"function":{"type":"Variable","name":"0_p[(19, 14, 16)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(6, 5, 11)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_p[(11, 9, 10)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(31, 19, 28)]"},"set":{"type":"LessThan","upper":1.0}},{"function":{"type":"Variable","name":"0_p[(9, 7, 10)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(14, 11, 18)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_p[(3, 3, 4)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_p[(29, 17, 27)]"},"set":{"type":"LessThan","upper":2.0}},{"function":{"type":"Variable","name":"0_p[(7, 6, 7)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(25, 22, 23)]"},"set":{"type":"LessThan","upper":0.33}},{"function":{"type":"Variable","name":"0_p[(4, 4, 5)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_p[(13, 9, 16)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(15, 12, 13)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(2, 2, 3)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_p[(27, 24, 25)]"},"set":{"type":"LessThan","upper":0.13}},{"function":{"type":"Variable","name":"0_p[(21, 18, 16)]"},"set":{"type":"LessThan","upper":1.0}},{"function":{"type":"Variable","name":"0_p[(26, 23, 24)]"},"set":{"type":"LessThan","upper":0.13}},{"function":{"type":"Variable","name":"0_p[(10, 8, 9)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(18, 14, 20)]"},"set":{"type":"LessThan","upper":0.47}},{"function":{"type":"Variable","name":"reservoir[1]_out"},"set":{"type":"LessThan","upper":0.1}},{"function":{"type":"Variable","name":"reservoir[2]_out"},"set":{"type":"LessThan","upper":137.99}},{"function":{"type":"Variable","name":"reservoir[3]_out"},"set":{"type":"LessThan","upper":0.042}},{"function":{"type":"Variable","name":"reservoir[4]_out"},"set":{"type":"LessThan","upper":16.76}},{"function":{"type":"Variable","name":"reservoir[5]_out"},"set":{"type":"LessThan","upper":10.35}},{"function":{"type":"Variable","name":"reservoir[6]_out"},"set":{"type":"LessThan","upper":0.32}},{"function":{"type":"Variable","name":"reservoir[7]_out"},"set":{"type":"LessThan","upper":9.72}},{"function":{"type":"Variable","name":"reservoir[8]_out"},"set":{"type":"LessThan","upper":0.07}},{"function":{"type":"Variable","name":"reservoir[9]_out"},"set":{"type":"LessThan","upper":0.04}},{"function":{"type":"Variable","name":"reservoir[10]_out"},"set":{"type":"LessThan","upper":0.0}},{"function":{"type":"Variable","name":"reservoir[11]_out"},"set":{"type":"LessThan","upper":2.93}},{"function":{"type":"Variable","name":"outflow[1]"},"set":{"type":"LessThan","upper":10.2926}},{"function":{"type":"Variable","name":"outflow[2]"},"set":{"type":"LessThan","upper":10.5531}},{"function":{"type":"Variable","name":"outflow[3]"},"set":{"type":"LessThan","upper":0.7854}},{"function":{"type":"Variable","name":"outflow[4]"},"set":{"type":"LessThan","upper":3.63}},{"function":{"type":"Variable","name":"outflow[5]"},"set":{"type":"LessThan","upper":8.74}},{"function":{"type":"Variable","name":"outflow[6]"},"set":{"type":"LessThan","upper":17.01}},{"function":{"type":"Variable","name":"outflow[7]"},"set":{"type":"LessThan","upper":1.25}},{"function":{"type":"Variable","name":"outflow[8]"},"set":{"type":"LessThan","upper":7.0}},{"function":{"type":"Variable","name":"outflow[9]"},"set":{"type":"LessThan","upper":11.0}},{"function":{"type":"Variable","name":"outflow[10]"},"set":{"type":"LessThan","upper":0.84}},{"function":{"type":"Variable","name":"outflow[11]"},"set":{"type":"LessThan","upper":3.24}}]} \ No newline at end of file diff --git a/examples/HydroPowerModels/bolivia/SOCWRConicPowerModel.mof.json b/examples/HydroPowerModels/bolivia/SOCWRConicPowerModel.mof.json index 14d2ff7..811bd1c 100644 --- a/examples/HydroPowerModels/bolivia/SOCWRConicPowerModel.mof.json +++ b/examples/HydroPowerModels/bolivia/SOCWRConicPowerModel.mof.json @@ -1,21020 +1 @@ -{ - "name": "MathOptFormat Model", - "version": { - "major": 1, - "minor": 7 - }, - "variables": [ - { - "name": "reservoir[1]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[2]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[3]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[4]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[5]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[6]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[7]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[8]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[9]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[10]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[11]_in", - "primal_start": 0.0 - }, - { - "name": "inflow[1]", - "primal_start": 0.0 - }, - { - "name": "inflow[2]", - "primal_start": 0.0 - }, - { - "name": "inflow[3]", - "primal_start": 0.0 - }, - { - "name": "inflow[4]", - "primal_start": 0.0 - }, - { - "name": "inflow[5]", - "primal_start": 0.0 - }, - { - "name": "inflow[6]", - "primal_start": 0.0 - }, - { - "name": "inflow[7]", - "primal_start": 0.0 - }, - { - "name": "inflow[8]", - "primal_start": 0.0 - }, - { - "name": "inflow[9]", - "primal_start": 0.0 - }, - { - "name": "inflow[10]", - "primal_start": 0.0 - }, - { - "name": "inflow[11]", - "primal_start": 0.0 - }, - { - "name": "0_w[5]", - "primal_start": 1.001 - }, - { - "name": "0_w[16]", - "primal_start": 1.001 - }, - { - "name": "0_w[20]", - "primal_start": 1.001 - }, - { - "name": "0_w[12]", - "primal_start": 1.001 - }, - { - "name": "0_w[24]", - "primal_start": 1.001 - }, - { - "name": "0_w[28]", - "primal_start": 1.001 - }, - { - "name": "0_w[8]", - "primal_start": 1.001 - }, - { - "name": "0_w[17]", - "primal_start": 1.001 - }, - { - "name": "0_w[1]", - "primal_start": 1.001 - }, - { - "name": "0_w[23]", - "primal_start": 1.001 - }, - { - "name": "0_w[22]", - "primal_start": 1.001 - }, - { - "name": "0_w[19]", - "primal_start": 1.001 - }, - { - "name": "0_w[6]", - "primal_start": 1.001 - }, - { - "name": "0_w[11]", - "primal_start": 1.001 - }, - { - "name": "0_w[9]", - "primal_start": 1.001 - }, - { - "name": "0_w[14]", - "primal_start": 1.001 - }, - { - "name": "0_w[3]", - "primal_start": 1.001 - }, - { - "name": "0_w[7]", - "primal_start": 1.001 - }, - { - "name": "0_w[25]", - "primal_start": 1.001 - }, - { - "name": "0_w[4]", - "primal_start": 1.001 - }, - { - "name": "0_w[13]", - "primal_start": 1.001 - }, - { - "name": "0_w[15]", - "primal_start": 1.001 - }, - { - "name": "0_w[2]", - "primal_start": 1.001 - }, - { - "name": "0_w[27]", - "primal_start": 1.001 - }, - { - "name": "0_w[21]", - "primal_start": 1.001 - }, - { - "name": "0_w[26]", - "primal_start": 1.001 - }, - { - "name": "0_w[10]", - "primal_start": 1.001 - }, - { - "name": "0_w[18]", - "primal_start": 1.001 - }, - { - "name": "0_wr[(18, 16)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(19, 28)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(11, 18)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(4, 5)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(23, 24)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(12, 13)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(9, 10)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(9, 12)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(25, 26)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(7, 8)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(21, 22)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(5, 11)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(14, 15)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(7, 10)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(8, 9)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(5, 6)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(2, 1)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(3, 4)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(9, 16)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(14, 20)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(16, 19)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(14, 16)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(2, 3)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(16, 17)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(24, 25)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(13, 14)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(22, 23)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(6, 7)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(20, 21)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(17, 27)]", - "primal_start": 1.0 - }, - { - "name": "0_wi[(18, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(19, 28)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(11, 18)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(4, 5)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(23, 24)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(12, 13)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(9, 10)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(9, 12)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(25, 26)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(7, 8)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(21, 22)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(5, 11)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(14, 15)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(7, 10)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(8, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(5, 6)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(2, 1)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(3, 4)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(9, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(14, 20)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(16, 19)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(14, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(2, 3)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(16, 17)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(24, 25)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(13, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(22, 23)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(6, 7)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(20, 21)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(17, 27)]", - "primal_start": 0.0 - }, - { - "name": "0_pg[5]", - "primal_start": 0.0 - }, - { - "name": "0_pg[16]", - "primal_start": 0.0 - }, - { - "name": "0_pg[20]", - "primal_start": 0.0 - }, - { - "name": "0_pg[12]", - "primal_start": 0.0 - }, - { - "name": "0_pg[24]", - "primal_start": 0.0 - }, - { - "name": "0_pg[28]", - "primal_start": 0.0 - }, - { - "name": "0_pg[8]", - "primal_start": 0.0 - }, - { - "name": "0_pg[17]", - "primal_start": 0.0 - }, - { - "name": "0_pg[30]", - "primal_start": 0.0 - }, - { - "name": "0_pg[1]", - "primal_start": 0.0 - }, - { - "name": "0_pg[23]", - "primal_start": 0.0 - }, - { - "name": "0_pg[32]", - "primal_start": 0.0 - }, - { - "name": "0_pg[22]", - "primal_start": 0.0 - }, - { - "name": "0_pg[6]", - "primal_start": 0.0 - }, - { - "name": "0_pg[19]", - "primal_start": 0.0 - }, - { - "name": "0_pg[11]", - "primal_start": 0.0 - }, - { - "name": "0_pg[31]", - "primal_start": 0.0 - }, - { - "name": "0_pg[9]", - "primal_start": 0.0 - }, - { - "name": "0_pg[14]", - "primal_start": 0.0 - }, - { - "name": "0_pg[3]", - "primal_start": 0.0 - }, - { - "name": "0_pg[29]", - "primal_start": 0.0 - }, - { - "name": "0_pg[33]", - "primal_start": 0.0 - }, - { - "name": "0_pg[25]", - "primal_start": 0.0 - }, - { - "name": "0_pg[7]", - "primal_start": 0.0 - }, - { - "name": "0_pg[34]", - "primal_start": 0.0 - }, - { - "name": "0_pg[4]", - "primal_start": 0.0 - }, - { - "name": "0_pg[13]", - "primal_start": 0.0 - }, - { - "name": "0_pg[15]", - "primal_start": 0.0 - }, - { - "name": "0_pg[2]", - "primal_start": 0.0 - }, - { - "name": "0_pg[27]", - "primal_start": 0.0 - }, - { - "name": "0_pg[21]", - "primal_start": 0.0 - }, - { - "name": "0_pg[26]", - "primal_start": 0.0 - }, - { - "name": "0_pg[10]", - "primal_start": 0.0 - }, - { - "name": "0_pg[18]", - "primal_start": 0.0 - }, - { - "name": "0_qg[5]", - "primal_start": 0.0 - }, - { - "name": "0_qg[16]", - "primal_start": 0.0 - }, - { - "name": "0_qg[20]", - "primal_start": 0.0 - }, - { - "name": "0_qg[12]", - "primal_start": 0.0 - }, - { - "name": "0_qg[24]", - "primal_start": 0.0 - }, - { - "name": "0_qg[28]", - "primal_start": 0.0 - }, - { - "name": "0_qg[8]", - "primal_start": 0.0 - }, - { - "name": "0_qg[17]", - "primal_start": 0.0 - }, - { - "name": "0_qg[30]", - "primal_start": 0.0 - }, - { - "name": "0_qg[1]", - "primal_start": 0.0 - }, - { - "name": "0_qg[23]", - "primal_start": 0.0 - }, - { - "name": "0_qg[32]", - "primal_start": 0.0 - }, - { - "name": "0_qg[22]", - "primal_start": 0.0 - }, - { - "name": "0_qg[6]", - "primal_start": 0.0 - }, - { - "name": "0_qg[19]", - "primal_start": 0.0 - }, - { - "name": "0_qg[11]", - "primal_start": 0.0 - }, - { - "name": "0_qg[31]", - "primal_start": 0.0 - }, - { - "name": "0_qg[9]", - "primal_start": 0.0 - }, - { - "name": "0_qg[14]", - "primal_start": 0.0 - }, - { - "name": "0_qg[3]", - "primal_start": 0.0 - }, - { - "name": "0_qg[29]", - "primal_start": 0.0 - }, - { - "name": "0_qg[33]", - "primal_start": 0.0 - }, - { - "name": "0_qg[25]", - "primal_start": 0.0 - }, - { - "name": "0_qg[7]", - "primal_start": 0.0 - }, - { - "name": "0_qg[34]", - "primal_start": 0.0 - }, - { - "name": "0_qg[4]", - "primal_start": 0.0 - }, - { - "name": "0_qg[13]", - "primal_start": 0.0 - }, - { - "name": "0_qg[15]", - "primal_start": 0.0 - }, - { - "name": "0_qg[2]", - "primal_start": 0.0 - }, - { - "name": "0_qg[27]", - "primal_start": 0.0 - }, - { - "name": "0_qg[21]", - "primal_start": 0.0 - }, - { - "name": "0_qg[26]", - "primal_start": 0.0 - }, - { - "name": "0_qg[10]", - "primal_start": 0.0 - }, - { - "name": "0_qg[18]", - "primal_start": 0.0 - }, - { - "name": "0_p[(5, 5, 6)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(16, 13, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(20, 16, 17)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(12, 9, 12)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(24, 21, 22)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(28, 25, 26)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(8, 7, 8)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(17, 14, 15)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(30, 19, 28)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(1, 2, 1)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(23, 20, 21)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(22, 16, 19)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(19, 14, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(6, 5, 11)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(11, 9, 10)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(31, 19, 28)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(9, 7, 10)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(14, 11, 18)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(3, 3, 4)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(29, 17, 27)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(7, 6, 7)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(25, 22, 23)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(4, 4, 5)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(13, 9, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(15, 12, 13)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(2, 2, 3)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(27, 24, 25)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(21, 18, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(26, 23, 24)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(10, 8, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(18, 14, 20)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(5, 6, 5)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(16, 14, 13)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(20, 17, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(12, 12, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(24, 22, 21)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(28, 26, 25)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(8, 8, 7)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(17, 15, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(30, 28, 19)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(1, 1, 2)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(23, 21, 20)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(22, 19, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(19, 16, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(6, 11, 5)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(11, 10, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(31, 28, 19)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(9, 10, 7)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(14, 18, 11)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(3, 4, 3)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(29, 27, 17)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(7, 7, 6)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(25, 23, 22)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(4, 5, 4)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(13, 16, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(15, 13, 12)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(2, 3, 2)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(27, 25, 24)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(21, 16, 18)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(26, 24, 23)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(10, 9, 8)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(18, 20, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(5, 5, 6)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(16, 13, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(20, 16, 17)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(12, 9, 12)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(24, 21, 22)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(28, 25, 26)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(8, 7, 8)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(17, 14, 15)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(30, 19, 28)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(1, 2, 1)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(23, 20, 21)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(22, 16, 19)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(19, 14, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(6, 5, 11)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(11, 9, 10)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(31, 19, 28)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(9, 7, 10)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(14, 11, 18)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(3, 3, 4)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(29, 17, 27)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(7, 6, 7)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(25, 22, 23)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(4, 4, 5)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(13, 9, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(15, 12, 13)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(2, 2, 3)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(27, 24, 25)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(21, 18, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(26, 23, 24)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(10, 8, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(18, 14, 20)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(5, 6, 5)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(16, 14, 13)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(20, 17, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(12, 12, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(24, 22, 21)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(28, 26, 25)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(8, 8, 7)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(17, 15, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(30, 28, 19)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(1, 1, 2)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(23, 21, 20)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(22, 19, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(19, 16, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(6, 11, 5)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(11, 10, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(31, 28, 19)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(9, 10, 7)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(14, 18, 11)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(3, 4, 3)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(29, 27, 17)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(7, 7, 6)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(25, 23, 22)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(4, 5, 4)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(13, 16, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(15, 13, 12)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(2, 3, 2)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(27, 25, 24)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(21, 16, 18)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(26, 24, 23)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(10, 9, 8)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(18, 20, 14)]", - "primal_start": 0.0 - }, - { - "name": "reservoir[1]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[2]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[3]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[4]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[5]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[6]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[7]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[8]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[9]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[10]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[11]_out", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[1]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[2]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[3]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[4]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[5]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[6]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[7]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[8]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[9]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[10]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[11]", - "primal_start": 0.0 - }, - { - "name": "outflow[1]", - "primal_start": 0.0 - }, - { - "name": "outflow[2]", - "primal_start": 0.0 - }, - { - "name": "outflow[3]", - "primal_start": 0.0 - }, - { - "name": "outflow[4]", - "primal_start": 0.0 - }, - { - "name": "outflow[5]", - "primal_start": 0.0 - }, - { - "name": "outflow[6]", - "primal_start": 0.0 - }, - { - "name": "outflow[7]", - "primal_start": 0.0 - }, - { - "name": "outflow[8]", - "primal_start": 0.0 - }, - { - "name": "outflow[9]", - "primal_start": 0.0 - }, - { - "name": "outflow[10]", - "primal_start": 0.0 - }, - { - "name": "outflow[11]", - "primal_start": 0.0 - }, - { - "name": "spill[1]", - "primal_start": 0.0 - }, - { - "name": "spill[2]", - "primal_start": 0.0 - }, - { - "name": "spill[3]", - "primal_start": 0.0 - }, - { - "name": "spill[4]", - "primal_start": 0.0 - }, - { - "name": "spill[5]", - "primal_start": 0.0 - }, - { - "name": "spill[6]", - "primal_start": 0.0 - }, - { - "name": "spill[7]", - "primal_start": 0.0 - }, - { - "name": "spill[8]", - "primal_start": 0.0 - }, - { - "name": "spill[9]", - "primal_start": 0.0 - }, - { - "name": "spill[10]", - "primal_start": 0.0 - }, - { - "name": "spill[11]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[1]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[2]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[3]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[4]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[5]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[6]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[7]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[8]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[9]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[10]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[11]", - "primal_start": 0.0 - }, - { - "name": "deficit[1]", - "primal_start": 0.0 - }, - { - "name": "deficit[2]", - "primal_start": 0.0 - }, - { - "name": "deficit[3]", - "primal_start": 0.0 - }, - { - "name": "deficit[4]", - "primal_start": 0.0 - }, - { - "name": "deficit[5]", - "primal_start": 0.0 - }, - { - "name": "deficit[6]", - "primal_start": 0.0 - }, - { - "name": "deficit[7]", - "primal_start": 0.0 - }, - { - "name": "deficit[8]", - "primal_start": 0.0 - }, - { - "name": "deficit[9]", - "primal_start": 0.0 - }, - { - "name": "deficit[10]", - "primal_start": 0.0 - }, - { - "name": "deficit[11]", - "primal_start": 0.0 - }, - { - "name": "deficit[12]", - "primal_start": 0.0 - }, - { - "name": "deficit[13]", - "primal_start": 0.0 - }, - { - "name": "deficit[14]", - "primal_start": 0.0 - }, - { - "name": "deficit[15]", - "primal_start": 0.0 - }, - { - "name": "deficit[16]", - "primal_start": 0.0 - }, - { - "name": "deficit[17]", - "primal_start": 0.0 - }, - { - "name": "deficit[18]", - "primal_start": 0.0 - }, - { - "name": "deficit[19]", - "primal_start": 0.0 - }, - { - "name": "deficit[20]", - "primal_start": 0.0 - }, - { - "name": "deficit[21]", - "primal_start": 0.0 - }, - { - "name": "deficit[22]", - "primal_start": 0.0 - }, - { - "name": "deficit[23]", - "primal_start": 0.0 - }, - { - "name": "deficit[24]", - "primal_start": 0.0 - }, - { - "name": "deficit[25]", - "primal_start": 0.0 - }, - { - "name": "deficit[26]", - "primal_start": 0.0 - }, - { - "name": "deficit[27]", - "primal_start": 0.0 - }, - { - "name": "deficit[28]", - "primal_start": 0.0 - } - ], - "objective": { - "sense": "min", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 6000.0, - "variable": "deficit[1]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[2]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[3]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[4]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[5]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[6]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[7]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[8]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[9]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[10]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[11]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[12]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[13]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[14]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[15]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[16]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[17]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[18]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[19]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[20]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[21]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[22]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[23]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[24]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[25]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[26]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[27]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[28]" - }, - { - "coefficient": 2268.0, - "variable": "0_pg[5]" - }, - { - "coefficient": 2059.0, - "variable": "0_pg[16]" - }, - { - "coefficient": 1780.0, - "variable": "0_pg[20]" - }, - { - "coefficient": 1576.0, - "variable": "0_pg[12]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[24]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[28]" - }, - { - "coefficient": 1754.0, - "variable": "0_pg[8]" - }, - { - "coefficient": 2059.0, - "variable": "0_pg[17]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[30]" - }, - { - "coefficient": 1918.0, - "variable": "0_pg[1]" - }, - { - "coefficient": 4244.0, - "variable": "0_pg[23]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[32]" - }, - { - "coefficient": 1517.0, - "variable": "0_pg[22]" - }, - { - "coefficient": 2131.0, - "variable": "0_pg[6]" - }, - { - "coefficient": 1780.0, - "variable": "0_pg[19]" - }, - { - "coefficient": 1576.0, - "variable": "0_pg[11]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[31]" - }, - { - "coefficient": 1576.0, - "variable": "0_pg[9]" - }, - { - "coefficient": 1404.0, - "variable": "0_pg[14]" - }, - { - "coefficient": 2184.0, - "variable": "0_pg[3]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[29]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[33]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[25]" - }, - { - "coefficient": 1822.0, - "variable": "0_pg[7]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[34]" - }, - { - "coefficient": 2179.0, - "variable": "0_pg[4]" - }, - { - "coefficient": 1404.0, - "variable": "0_pg[13]" - }, - { - "coefficient": 2077.0, - "variable": "0_pg[15]" - }, - { - "coefficient": 2120.0, - "variable": "0_pg[2]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[27]" - }, - { - "coefficient": 1598.0, - "variable": "0_pg[21]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[26]" - }, - { - "coefficient": 1576.0, - "variable": "0_pg[10]" - }, - { - "coefficient": 2059.0, - "variable": "0_pg[18]" - } - ], - "constant": 0.0 - } - }, - "constraints": [ - { - "name": "c1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(5, 5, 6)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(6, 5, 11)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(4, 5, 4)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[5]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(5, 5, 6)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(6, 5, 11)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(4, 5, 4)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c3", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(20, 16, 17)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(22, 16, 19)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(19, 16, 14)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(13, 16, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(21, 16, 18)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[16]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.21439096103324617 - } - }, - { - "name": "c4", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(20, 16, 17)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(22, 16, 19)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(19, 16, 14)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(13, 16, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(21, 16, 18)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.02572691532398954 - } - }, - { - "name": "c5", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(23, 20, 21)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(18, 20, 14)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[20]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.0015565421870758504 - } - }, - { - "name": "c6", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(23, 20, 21)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(18, 20, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.00018678506244910206 - } - }, - { - "name": "c7", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(15, 12, 13)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(12, 12, 9)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[12]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.05738794110411041 - } - }, - { - "name": "c8", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(15, 12, 13)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(12, 12, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.006886552932493249 - } - }, - { - "name": "c9", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(27, 24, 25)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(26, 24, 23)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[24]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.01804043447630477 - } - }, - { - "name": "c10", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(27, 24, 25)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(26, 24, 23)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.0021648521371565727 - } - }, - { - "name": "c11", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[28]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[30]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[29]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(30, 28, 19)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(31, 28, 19)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[28]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c12", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[28]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[30]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[29]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(30, 28, 19)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(31, 28, 19)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c13", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[25]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(10, 8, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(8, 8, 7)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[8]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c14", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[25]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(10, 8, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(8, 8, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c15", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(29, 17, 27)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(20, 17, 16)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[17]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.267753330934522 - } - }, - { - "name": "c16", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(29, 17, 27)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(20, 17, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.03213039971214264 - } - }, - { - "name": "c17", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[5]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[8]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[1]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[6]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[9]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[3]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[7]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[4]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[2]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[10]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 2)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.6075543555612704 - } - }, - { - "name": "c18", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[5]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[8]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[1]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[6]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[9]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[3]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[7]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[4]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[2]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[10]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.19290652266735245 - } - }, - { - "name": "c19", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[21]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(26, 23, 24)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(25, 23, 22)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[23]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.0004825663866386638 - } - }, - { - "name": "c20", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[21]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(26, 23, 24)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(25, 23, 22)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -5.790796639663966e-5 - } - }, - { - "name": "c21", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[34]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(25, 22, 23)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(24, 22, 21)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[22]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.12074817048704867 - } - }, - { - "name": "c22", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[34]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(25, 22, 23)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(24, 22, 21)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.01448978045844584 - } - }, - { - "name": "c23", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[20]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[32]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[19]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[31]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[33]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(30, 19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(31, 19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(22, 19, 16)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[19]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.4735118986170044 - } - }, - { - "name": "c24", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[20]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[32]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[19]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[31]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[33]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(30, 19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(31, 19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(22, 19, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.1768214278340405 - } - }, - { - "name": "c25", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(7, 6, 7)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(5, 6, 5)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c26", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(7, 6, 7)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(5, 6, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c27", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(14, 11, 18)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(6, 11, 5)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c28", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(14, 11, 18)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(6, 11, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c29", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[16]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[17]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[15]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[18]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(12, 9, 12)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(11, 9, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(13, 9, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(10, 9, 8)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.21593913974111698 - } - }, - { - "name": "c30", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[16]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[17]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[15]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[18]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(12, 9, 12)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(11, 9, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(13, 9, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(10, 9, 8)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.025912696768934037 - } - }, - { - "name": "c31", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(17, 14, 15)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(19, 14, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(18, 14, 20)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(16, 14, 13)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[14]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c32", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(17, 14, 15)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(19, 14, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(18, 14, 20)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(16, 14, 13)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c33", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[12]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[11]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[14]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[13]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 3, 4)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c34", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[12]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[11]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[14]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[13]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 3, 4)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c35", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[24]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(8, 7, 8)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(9, 7, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(7, 7, 6)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c36", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[24]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(8, 7, 8)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(9, 7, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(7, 7, 6)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c37", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(28, 25, 26)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(27, 25, 24)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[25]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.0004825663866386638 - } - }, - { - "name": "c38", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(28, 25, 26)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(27, 25, 24)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -5.790796639663966e-5 - } - }, - { - "name": "c39", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(4, 4, 5)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 4, 3)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.02040724338005229 - } - }, - { - "name": "c40", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(4, 4, 5)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 4, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.002448869205606275 - } - }, - { - "name": "c41", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(16, 13, 14)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(15, 13, 12)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[13]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.0004825663866386638 - } - }, - { - "name": "c42", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(16, 13, 14)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(15, 13, 12)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -5.790796639663966e-5 - } - }, - { - "name": "c43", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(17, 15, 14)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[15]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.10015864047547611 - } - }, - { - "name": "c44", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(17, 15, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.012019036857057132 - } - }, - { - "name": "c45", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(1, 2, 1)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c46", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(1, 2, 1)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c47", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[27]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(29, 27, 17)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[27]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c48", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[27]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(29, 27, 17)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c49", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(24, 21, 22)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(23, 21, 20)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[21]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c50", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(24, 21, 22)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(23, 21, 20)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c51", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[23]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[22]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(28, 26, 25)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[26]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.1700922829782978 - } - }, - { - "name": "c52", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[23]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[22]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(28, 26, 25)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.020411073957395734 - } - }, - { - "name": "c53", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[26]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(11, 10, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(9, 10, 7)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.5563327884359863 - } - }, - { - "name": "c54", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[26]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(11, 10, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(9, 10, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.06675993461231836 - } - }, - { - "name": "c55", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(21, 18, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(14, 18, 11)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[18]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c56", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(21, 18, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(14, 18, 11)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c57", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.4213950047523992, - "variable": "0_w[5]" - }, - { - "coefficient": 0.4213950047523992, - "variable": "0_wr[(5, 6)]" - }, - { - "coefficient": -12.485777918589607, - "variable": "0_wi[(5, 6)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(5, 5, 6)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c58", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -12.485777918589607, - "variable": "0_w[5]" - }, - { - "coefficient": 12.485777918589607, - "variable": "0_wr[(5, 6)]" - }, - { - "coefficient": 0.4213950047523992, - "variable": "0_wi[(5, 6)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(5, 5, 6)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c59", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.4213950047523992, - "variable": "0_w[6]" - }, - { - "coefficient": 0.4213950047523992, - "variable": "0_wr[(5, 6)]" - }, - { - "coefficient": 12.485777918589607, - "variable": "0_wi[(5, 6)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(5, 6, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c60", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -12.485777918589607, - "variable": "0_w[6]" - }, - { - "coefficient": 12.485777918589607, - "variable": "0_wr[(5, 6)]" - }, - { - "coefficient": -0.4213950047523992, - "variable": "0_wi[(5, 6)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(5, 6, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c61", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.46024690223052, - "variable": "0_w[13]" - }, - { - "coefficient": 2.46024690223052, - "variable": "0_wr[(13, 14)]" - }, - { - "coefficient": -6.795713842466891, - "variable": "0_wi[(13, 14)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(16, 13, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c62", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -6.787563842466891, - "variable": "0_w[13]" - }, - { - "coefficient": 6.795713842466891, - "variable": "0_wr[(13, 14)]" - }, - { - "coefficient": 2.46024690223052, - "variable": "0_wi[(13, 14)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(16, 13, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c63", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.46024690223052, - "variable": "0_w[14]" - }, - { - "coefficient": 2.46024690223052, - "variable": "0_wr[(13, 14)]" - }, - { - "coefficient": 6.795713842466891, - "variable": "0_wi[(13, 14)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(16, 14, 13)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c64", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -6.787563842466891, - "variable": "0_w[14]" - }, - { - "coefficient": 6.795713842466891, - "variable": "0_wr[(13, 14)]" - }, - { - "coefficient": -2.46024690223052, - "variable": "0_wi[(13, 14)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(16, 14, 13)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c65", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.7456627284627748, - "variable": "0_w[16]" - }, - { - "coefficient": 0.7456627284627748, - "variable": "0_wr[(16, 17)]" - }, - { - "coefficient": -10.149298248521102, - "variable": "0_wi[(16, 17)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(20, 16, 17)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c66", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -10.149298248521102, - "variable": "0_w[16]" - }, - { - "coefficient": 10.149298248521102, - "variable": "0_wr[(16, 17)]" - }, - { - "coefficient": 0.7456627284627748, - "variable": "0_wi[(16, 17)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(20, 16, 17)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c67", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.7456627284627748, - "variable": "0_w[17]" - }, - { - "coefficient": 0.7456627284627748, - "variable": "0_wr[(16, 17)]" - }, - { - "coefficient": 10.149298248521102, - "variable": "0_wi[(16, 17)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(20, 17, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c68", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -10.149298248521102, - "variable": "0_w[17]" - }, - { - "coefficient": 10.149298248521102, - "variable": "0_wr[(16, 17)]" - }, - { - "coefficient": -0.7456627284627748, - "variable": "0_wi[(16, 17)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(20, 17, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c69", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.3473152225768015, - "variable": "0_w[9]" - }, - { - "coefficient": 2.3473152225768015, - "variable": "0_wr[(9, 12)]" - }, - { - "coefficient": -6.481250938450924, - "variable": "0_wi[(9, 12)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(12, 9, 12)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c70", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -6.472700938450925, - "variable": "0_w[9]" - }, - { - "coefficient": 6.481250938450924, - "variable": "0_wr[(9, 12)]" - }, - { - "coefficient": 2.3473152225768015, - "variable": "0_wi[(9, 12)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(12, 9, 12)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c71", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.3473152225768015, - "variable": "0_w[12]" - }, - { - "coefficient": 2.3473152225768015, - "variable": "0_wr[(9, 12)]" - }, - { - "coefficient": 6.481250938450924, - "variable": "0_wi[(9, 12)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(12, 12, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c72", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -6.472700938450925, - "variable": "0_w[12]" - }, - { - "coefficient": 6.481250938450924, - "variable": "0_wr[(9, 12)]" - }, - { - "coefficient": -2.3473152225768015, - "variable": "0_wi[(9, 12)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(12, 12, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c73", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.13631367642289954, - "variable": "0_w[21]" - }, - { - "coefficient": 0.13631367642289954, - "variable": "0_wr[(21, 22)]" - }, - { - "coefficient": -4.2328983731321435, - "variable": "0_wi[(21, 22)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(24, 21, 22)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c74", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -4.2328983731321435, - "variable": "0_w[21]" - }, - { - "coefficient": 4.2328983731321435, - "variable": "0_wr[(21, 22)]" - }, - { - "coefficient": 0.13631367642289954, - "variable": "0_wi[(21, 22)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(24, 21, 22)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c75", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.13631367642289954, - "variable": "0_w[22]" - }, - { - "coefficient": 0.13631367642289954, - "variable": "0_wr[(21, 22)]" - }, - { - "coefficient": 4.2328983731321435, - "variable": "0_wi[(21, 22)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(24, 22, 21)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c76", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -4.2328983731321435, - "variable": "0_w[22]" - }, - { - "coefficient": 4.2328983731321435, - "variable": "0_wr[(21, 22)]" - }, - { - "coefficient": -0.13631367642289954, - "variable": "0_wi[(21, 22)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(24, 22, 21)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c77", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0916977112407253, - "variable": "0_w[25]" - }, - { - "coefficient": 1.0916977112407253, - "variable": "0_wr[(25, 26)]" - }, - { - "coefficient": -2.091029561081878, - "variable": "0_wi[(25, 26)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(28, 25, 26)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c78", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.088179561081878, - "variable": "0_w[25]" - }, - { - "coefficient": 2.091029561081878, - "variable": "0_wr[(25, 26)]" - }, - { - "coefficient": 1.0916977112407253, - "variable": "0_wi[(25, 26)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(28, 25, 26)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c79", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0916977112407253, - "variable": "0_w[26]" - }, - { - "coefficient": 1.0916977112407253, - "variable": "0_wr[(25, 26)]" - }, - { - "coefficient": 2.091029561081878, - "variable": "0_wi[(25, 26)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(28, 26, 25)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c80", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.088179561081878, - "variable": "0_w[26]" - }, - { - "coefficient": 2.091029561081878, - "variable": "0_wr[(25, 26)]" - }, - { - "coefficient": -1.0916977112407253, - "variable": "0_wi[(25, 26)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(28, 26, 25)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c81", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -15.980730481506358, - "variable": "0_w[7]" - }, - { - "coefficient": 15.980730481506358, - "variable": "0_wr[(7, 8)]" - }, - { - "coefficient": -45.39453875906154, - "variable": "0_wi[(7, 8)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(8, 7, 8)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c82", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -45.39333875906154, - "variable": "0_w[7]" - }, - { - "coefficient": 45.39453875906154, - "variable": "0_wr[(7, 8)]" - }, - { - "coefficient": 15.980730481506358, - "variable": "0_wi[(7, 8)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(8, 7, 8)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c83", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -15.980730481506358, - "variable": "0_w[8]" - }, - { - "coefficient": 15.980730481506358, - "variable": "0_wr[(7, 8)]" - }, - { - "coefficient": 45.39453875906154, - "variable": "0_wi[(7, 8)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(8, 8, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c84", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -45.39333875906154, - "variable": "0_w[8]" - }, - { - "coefficient": 45.39453875906154, - "variable": "0_wr[(7, 8)]" - }, - { - "coefficient": -15.980730481506358, - "variable": "0_wi[(7, 8)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(8, 8, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c85", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.4325735387749903, - "variable": "0_w[14]" - }, - { - "coefficient": 1.4325735387749903, - "variable": "0_wr[(14, 15)]" - }, - { - "coefficient": -19.8968547052082, - "variable": "0_wi[(14, 15)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(17, 14, 15)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c86", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -19.8968547052082, - "variable": "0_w[14]" - }, - { - "coefficient": 19.8968547052082, - "variable": "0_wr[(14, 15)]" - }, - { - "coefficient": 1.4325735387749903, - "variable": "0_wi[(14, 15)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(17, 14, 15)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c87", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.4325735387749903, - "variable": "0_w[15]" - }, - { - "coefficient": 1.4325735387749903, - "variable": "0_wr[(14, 15)]" - }, - { - "coefficient": 19.8968547052082, - "variable": "0_wi[(14, 15)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(17, 15, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c88", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -19.8968547052082, - "variable": "0_w[15]" - }, - { - "coefficient": 19.8968547052082, - "variable": "0_wr[(14, 15)]" - }, - { - "coefficient": -1.4325735387749903, - "variable": "0_wi[(14, 15)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(17, 15, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c89", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8777625235737184, - "variable": "0_w[19]" - }, - { - "coefficient": 0.8777625235737184, - "variable": "0_wr[(19, 28)]" - }, - { - "coefficient": -9.121944633618186, - "variable": "0_wi[(19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(30, 19, 28)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c90", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -9.097144633618186, - "variable": "0_w[19]" - }, - { - "coefficient": 9.121944633618186, - "variable": "0_wr[(19, 28)]" - }, - { - "coefficient": 0.8777625235737184, - "variable": "0_wi[(19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(30, 19, 28)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c91", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8777625235737184, - "variable": "0_w[28]" - }, - { - "coefficient": 0.8777625235737184, - "variable": "0_wr[(19, 28)]" - }, - { - "coefficient": 9.121944633618186, - "variable": "0_wi[(19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(30, 28, 19)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c92", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -9.097144633618186, - "variable": "0_w[28]" - }, - { - "coefficient": 9.121944633618186, - "variable": "0_wr[(19, 28)]" - }, - { - "coefficient": -0.8777625235737184, - "variable": "0_wi[(19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(30, 28, 19)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c93", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.28958087993976717, - "variable": "0_w[2]" - }, - { - "coefficient": 0.28958087993976717, - "variable": "0_wr[(2, 1)]" - }, - { - "coefficient": -9.363115118052471, - "variable": "0_wi[(2, 1)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 2, 1)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c94", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -9.363115118052471, - "variable": "0_w[2]" - }, - { - "coefficient": 9.363115118052471, - "variable": "0_wr[(2, 1)]" - }, - { - "coefficient": 0.28958087993976717, - "variable": "0_wi[(2, 1)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 2, 1)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c95", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.28958087993976717, - "variable": "0_w[1]" - }, - { - "coefficient": 0.28958087993976717, - "variable": "0_wr[(2, 1)]" - }, - { - "coefficient": 9.363115118052471, - "variable": "0_wi[(2, 1)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c96", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -9.363115118052471, - "variable": "0_w[1]" - }, - { - "coefficient": 9.363115118052471, - "variable": "0_wr[(2, 1)]" - }, - { - "coefficient": -0.28958087993976717, - "variable": "0_wi[(2, 1)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c97", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.128676282013955, - "variable": "0_w[20]" - }, - { - "coefficient": 1.128676282013955, - "variable": "0_wr[(20, 21)]" - }, - { - "coefficient": -3.33399327650884, - "variable": "0_wi[(20, 21)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(23, 20, 21)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c98", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -3.3189932765088397, - "variable": "0_w[20]" - }, - { - "coefficient": 3.33399327650884, - "variable": "0_wr[(20, 21)]" - }, - { - "coefficient": 1.128676282013955, - "variable": "0_wi[(20, 21)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(23, 20, 21)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c99", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.128676282013955, - "variable": "0_w[21]" - }, - { - "coefficient": 1.128676282013955, - "variable": "0_wr[(20, 21)]" - }, - { - "coefficient": 3.33399327650884, - "variable": "0_wi[(20, 21)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(23, 21, 20)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c100", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -3.3189932765088397, - "variable": "0_w[21]" - }, - { - "coefficient": 3.33399327650884, - "variable": "0_wr[(20, 21)]" - }, - { - "coefficient": -1.128676282013955, - "variable": "0_wi[(20, 21)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(23, 21, 20)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c101", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8287243608560181, - "variable": "0_w[16]" - }, - { - "coefficient": 0.8287243608560181, - "variable": "0_wr[(16, 19)]" - }, - { - "coefficient": -2.8140484527509644, - "variable": "0_wi[(16, 19)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(22, 16, 19)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c102", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.7777484527509646, - "variable": "0_w[16]" - }, - { - "coefficient": 2.8140484527509644, - "variable": "0_wr[(16, 19)]" - }, - { - "coefficient": 0.8287243608560181, - "variable": "0_wi[(16, 19)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(22, 16, 19)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c103", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8287243608560181, - "variable": "0_w[19]" - }, - { - "coefficient": 0.8287243608560181, - "variable": "0_wr[(16, 19)]" - }, - { - "coefficient": 2.8140484527509644, - "variable": "0_wi[(16, 19)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(22, 19, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c104", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.7777484527509646, - "variable": "0_w[19]" - }, - { - "coefficient": 2.8140484527509644, - "variable": "0_wr[(16, 19)]" - }, - { - "coefficient": -0.8287243608560181, - "variable": "0_wi[(16, 19)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(22, 19, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c105", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.2416585439004273, - "variable": "0_w[14]" - }, - { - "coefficient": 1.2416585439004273, - "variable": "0_wr[(14, 16)]" - }, - { - "coefficient": -3.667991302391842, - "variable": "0_wi[(14, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(19, 14, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c106", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -3.654341302391842, - "variable": "0_w[14]" - }, - { - "coefficient": 3.667991302391842, - "variable": "0_wr[(14, 16)]" - }, - { - "coefficient": 1.2416585439004273, - "variable": "0_wi[(14, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(19, 14, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c107", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.2416585439004273, - "variable": "0_w[16]" - }, - { - "coefficient": 1.2416585439004273, - "variable": "0_wr[(14, 16)]" - }, - { - "coefficient": 3.667991302391842, - "variable": "0_wi[(14, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(19, 16, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c108", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -3.654341302391842, - "variable": "0_w[16]" - }, - { - "coefficient": 3.667991302391842, - "variable": "0_wr[(14, 16)]" - }, - { - "coefficient": -1.2416585439004273, - "variable": "0_wi[(14, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(19, 16, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c109", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -3.027806843733998, - "variable": "0_w[5]" - }, - { - "coefficient": 3.027806843733998, - "variable": "0_wr[(5, 11)]" - }, - { - "coefficient": -20.88296190751831, - "variable": "0_wi[(5, 11)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(6, 5, 11)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c110", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -20.83991190751831, - "variable": "0_w[5]" - }, - { - "coefficient": 20.88296190751831, - "variable": "0_wr[(5, 11)]" - }, - { - "coefficient": 3.027806843733998, - "variable": "0_wi[(5, 11)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(6, 5, 11)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c111", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -3.027806843733998, - "variable": "0_w[11]" - }, - { - "coefficient": 3.027806843733998, - "variable": "0_wr[(5, 11)]" - }, - { - "coefficient": 20.88296190751831, - "variable": "0_wi[(5, 11)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(6, 11, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c112", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -20.83991190751831, - "variable": "0_w[11]" - }, - { - "coefficient": 20.88296190751831, - "variable": "0_wr[(5, 11)]" - }, - { - "coefficient": -3.027806843733998, - "variable": "0_wi[(5, 11)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(6, 11, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c113", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -17.788682717374634, - "variable": "0_w[9]" - }, - { - "coefficient": 17.788682717374634, - "variable": "0_wr[(9, 10)]" - }, - { - "coefficient": -52.44594387363901, - "variable": "0_wi[(9, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(11, 9, 10)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c114", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -52.44499387363901, - "variable": "0_w[9]" - }, - { - "coefficient": 52.44594387363901, - "variable": "0_wr[(9, 10)]" - }, - { - "coefficient": 17.788682717374634, - "variable": "0_wi[(9, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(11, 9, 10)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c115", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -17.788682717374634, - "variable": "0_w[10]" - }, - { - "coefficient": 17.788682717374634, - "variable": "0_wr[(9, 10)]" - }, - { - "coefficient": 52.44594387363901, - "variable": "0_wi[(9, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(11, 10, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c116", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -52.44499387363901, - "variable": "0_w[10]" - }, - { - "coefficient": 52.44594387363901, - "variable": "0_wr[(9, 10)]" - }, - { - "coefficient": -17.788682717374634, - "variable": "0_wi[(9, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(11, 10, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c117", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.9656776626482336, - "variable": "0_w[19]" - }, - { - "coefficient": 0.9656776626482336, - "variable": "0_wr[(19, 28)]" - }, - { - "coefficient": -5.498037005409949, - "variable": "0_wi[(19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(31, 19, 28)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c118", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -5.487437005409949, - "variable": "0_w[19]" - }, - { - "coefficient": 5.498037005409949, - "variable": "0_wr[(19, 28)]" - }, - { - "coefficient": 0.9656776626482336, - "variable": "0_wi[(19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(31, 19, 28)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c119", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.9656776626482336, - "variable": "0_w[28]" - }, - { - "coefficient": 0.9656776626482336, - "variable": "0_wr[(19, 28)]" - }, - { - "coefficient": 5.498037005409949, - "variable": "0_wi[(19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(31, 28, 19)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c120", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -5.487437005409949, - "variable": "0_w[28]" - }, - { - "coefficient": 5.498037005409949, - "variable": "0_wr[(19, 28)]" - }, - { - "coefficient": -0.9656776626482336, - "variable": "0_wi[(19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(31, 28, 19)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c121", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.3418494649701906, - "variable": "0_w[7]" - }, - { - "coefficient": 2.3418494649701906, - "variable": "0_wr[(7, 10)]" - }, - { - "coefficient": -6.467289330533839, - "variable": "0_wi[(7, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(9, 7, 10)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c122", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -6.458739330533839, - "variable": "0_w[7]" - }, - { - "coefficient": 6.467289330533839, - "variable": "0_wr[(7, 10)]" - }, - { - "coefficient": 2.3418494649701906, - "variable": "0_wi[(7, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(9, 7, 10)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c123", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.3418494649701906, - "variable": "0_w[10]" - }, - { - "coefficient": 2.3418494649701906, - "variable": "0_wr[(7, 10)]" - }, - { - "coefficient": 6.467289330533839, - "variable": "0_wi[(7, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(9, 10, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c124", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -6.458739330533839, - "variable": "0_w[10]" - }, - { - "coefficient": 6.467289330533839, - "variable": "0_wr[(7, 10)]" - }, - { - "coefficient": -2.3418494649701906, - "variable": "0_wi[(7, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(9, 10, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c125", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.2592269273704175, - "variable": "0_w[11]" - }, - { - "coefficient": 1.2592269273704175, - "variable": "0_wr[(11, 18)]" - }, - { - "coefficient": -8.698708713000553, - "variable": "0_wi[(11, 18)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(14, 11, 18)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c126", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -8.595708713000553, - "variable": "0_w[11]" - }, - { - "coefficient": 8.698708713000553, - "variable": "0_wr[(11, 18)]" - }, - { - "coefficient": 1.2592269273704175, - "variable": "0_wi[(11, 18)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(14, 11, 18)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c127", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.2592269273704175, - "variable": "0_w[18]" - }, - { - "coefficient": 1.2592269273704175, - "variable": "0_wr[(11, 18)]" - }, - { - "coefficient": 8.698708713000553, - "variable": "0_wi[(11, 18)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(14, 18, 11)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c128", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -8.595708713000553, - "variable": "0_w[18]" - }, - { - "coefficient": 8.698708713000553, - "variable": "0_wr[(11, 18)]" - }, - { - "coefficient": -1.2592269273704175, - "variable": "0_wi[(11, 18)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(14, 18, 11)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c129", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.5442206253457624, - "variable": "0_w[3]" - }, - { - "coefficient": 2.5442206253457624, - "variable": "0_wr[(3, 4)]" - }, - { - "coefficient": -17.010777436904807, - "variable": "0_wi[(3, 4)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 3, 4)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c130", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -16.954277436904807, - "variable": "0_w[3]" - }, - { - "coefficient": 17.010777436904807, - "variable": "0_wr[(3, 4)]" - }, - { - "coefficient": 2.5442206253457624, - "variable": "0_wi[(3, 4)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 3, 4)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c131", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.5442206253457624, - "variable": "0_w[4]" - }, - { - "coefficient": 2.5442206253457624, - "variable": "0_wr[(3, 4)]" - }, - { - "coefficient": 17.010777436904807, - "variable": "0_wi[(3, 4)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 4, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c132", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -16.954277436904807, - "variable": "0_w[4]" - }, - { - "coefficient": 17.010777436904807, - "variable": "0_wr[(3, 4)]" - }, - { - "coefficient": -2.5442206253457624, - "variable": "0_wi[(3, 4)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 4, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c133", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.5382017465334347, - "variable": "0_w[17]" - }, - { - "coefficient": 0.5382017465334347, - "variable": "0_wr[(17, 27)]" - }, - { - "coefficient": -1.6861921183958626, - "variable": "0_wi[(17, 27)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(29, 17, 27)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c134", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.6861921183958626, - "variable": "0_w[17]" - }, - { - "coefficient": 1.6861921183958626, - "variable": "0_wr[(17, 27)]" - }, - { - "coefficient": 0.5382017465334347, - "variable": "0_wi[(17, 27)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(29, 17, 27)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c135", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.5382017465334347, - "variable": "0_w[27]" - }, - { - "coefficient": 0.5382017465334347, - "variable": "0_wr[(17, 27)]" - }, - { - "coefficient": 1.6861921183958626, - "variable": "0_wi[(17, 27)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(29, 27, 17)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c136", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.6861921183958626, - "variable": "0_w[27]" - }, - { - "coefficient": 1.6861921183958626, - "variable": "0_wr[(17, 27)]" - }, - { - "coefficient": -0.5382017465334347, - "variable": "0_wi[(17, 27)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(29, 27, 17)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c137", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -10.614654857863137, - "variable": "0_w[6]" - }, - { - "coefficient": 10.614654857863137, - "variable": "0_wr[(6, 7)]" - }, - { - "coefficient": -31.512256609281188, - "variable": "0_wi[(6, 7)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(7, 6, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c138", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -31.510656609281188, - "variable": "0_w[6]" - }, - { - "coefficient": 31.512256609281188, - "variable": "0_wr[(6, 7)]" - }, - { - "coefficient": 10.614654857863137, - "variable": "0_wi[(6, 7)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(7, 6, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c139", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -10.614654857863137, - "variable": "0_w[7]" - }, - { - "coefficient": 10.614654857863137, - "variable": "0_wr[(6, 7)]" - }, - { - "coefficient": 31.512256609281188, - "variable": "0_wi[(6, 7)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(7, 7, 6)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c140", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -31.510656609281188, - "variable": "0_w[7]" - }, - { - "coefficient": 31.512256609281188, - "variable": "0_wr[(6, 7)]" - }, - { - "coefficient": -10.614654857863137, - "variable": "0_wi[(6, 7)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(7, 7, 6)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c141", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -4.66785040912336, - "variable": "0_w[22]" - }, - { - "coefficient": 4.66785040912336, - "variable": "0_wr[(22, 23)]" - }, - { - "coefficient": -8.939086077602251, - "variable": "0_wi[(22, 23)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(25, 22, 23)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c142", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -8.938436077602251, - "variable": "0_w[22]" - }, - { - "coefficient": 8.939086077602251, - "variable": "0_wr[(22, 23)]" - }, - { - "coefficient": 4.66785040912336, - "variable": "0_wi[(22, 23)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(25, 22, 23)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c143", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -4.66785040912336, - "variable": "0_w[23]" - }, - { - "coefficient": 4.66785040912336, - "variable": "0_wr[(22, 23)]" - }, - { - "coefficient": 8.939086077602251, - "variable": "0_wi[(22, 23)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(25, 23, 22)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c144", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -8.938436077602251, - "variable": "0_w[23]" - }, - { - "coefficient": 8.939086077602251, - "variable": "0_wr[(22, 23)]" - }, - { - "coefficient": -4.66785040912336, - "variable": "0_wi[(22, 23)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(25, 23, 22)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c145", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.434853977156145, - "variable": "0_w[4]" - }, - { - "coefficient": 2.434853977156145, - "variable": "0_wr[(4, 5)]" - }, - { - "coefficient": -16.36003009370084, - "variable": "0_wi[(4, 5)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(4, 4, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c146", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -16.30153009370084, - "variable": "0_w[4]" - }, - { - "coefficient": 16.36003009370084, - "variable": "0_wr[(4, 5)]" - }, - { - "coefficient": 2.434853977156145, - "variable": "0_wi[(4, 5)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(4, 4, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c147", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.434853977156145, - "variable": "0_w[5]" - }, - { - "coefficient": 2.434853977156145, - "variable": "0_wr[(4, 5)]" - }, - { - "coefficient": 16.36003009370084, - "variable": "0_wi[(4, 5)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(4, 5, 4)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c148", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -16.30153009370084, - "variable": "0_w[5]" - }, - { - "coefficient": 16.36003009370084, - "variable": "0_wr[(4, 5)]" - }, - { - "coefficient": -2.434853977156145, - "variable": "0_wi[(4, 5)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(4, 5, 4)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c149", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.64335500582701, - "variable": "0_w[9]" - }, - { - "coefficient": 0.64335500582701, - "variable": "0_wr[(9, 16)]" - }, - { - "coefficient": -1.8998888915041532, - "variable": "0_wi[(9, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(13, 9, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c150", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.8735888915041532, - "variable": "0_w[9]" - }, - { - "coefficient": 1.8998888915041532, - "variable": "0_wr[(9, 16)]" - }, - { - "coefficient": 0.64335500582701, - "variable": "0_wi[(9, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(13, 9, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c151", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.64335500582701, - "variable": "0_w[16]" - }, - { - "coefficient": 0.64335500582701, - "variable": "0_wr[(9, 16)]" - }, - { - "coefficient": 1.8998888915041532, - "variable": "0_wi[(9, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(13, 16, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c152", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.8735888915041532, - "variable": "0_w[16]" - }, - { - "coefficient": 1.8998888915041532, - "variable": "0_wr[(9, 16)]" - }, - { - "coefficient": -0.64335500582701, - "variable": "0_wi[(9, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(13, 16, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c153", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.5424832182137913, - "variable": "0_w[12]" - }, - { - "coefficient": 2.5424832182137913, - "variable": "0_wr[(12, 13)]" - }, - { - "coefficient": -7.029547007720768, - "variable": "0_wi[(12, 13)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(15, 12, 13)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c154", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -7.021647007720768, - "variable": "0_w[12]" - }, - { - "coefficient": 7.029547007720768, - "variable": "0_wr[(12, 13)]" - }, - { - "coefficient": 2.5424832182137913, - "variable": "0_wi[(12, 13)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(15, 12, 13)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c155", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.5424832182137913, - "variable": "0_w[13]" - }, - { - "coefficient": 2.5424832182137913, - "variable": "0_wr[(12, 13)]" - }, - { - "coefficient": 7.029547007720768, - "variable": "0_wi[(12, 13)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(15, 13, 12)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c156", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -7.021647007720768, - "variable": "0_w[13]" - }, - { - "coefficient": 7.029547007720768, - "variable": "0_wr[(12, 13)]" - }, - { - "coefficient": -2.5424832182137913, - "variable": "0_wi[(12, 13)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(15, 13, 12)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c157", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.070955528571676, - "variable": "0_w[2]" - }, - { - "coefficient": 1.070955528571676, - "variable": "0_wr[(2, 3)]" - }, - { - "coefficient": -7.165952433825185, - "variable": "0_wi[(2, 3)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c158", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -7.031952433825185, - "variable": "0_w[2]" - }, - { - "coefficient": 7.165952433825185, - "variable": "0_wr[(2, 3)]" - }, - { - "coefficient": 1.070955528571676, - "variable": "0_wi[(2, 3)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c159", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.070955528571676, - "variable": "0_w[3]" - }, - { - "coefficient": 1.070955528571676, - "variable": "0_wr[(2, 3)]" - }, - { - "coefficient": 7.165952433825185, - "variable": "0_wi[(2, 3)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c160", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -7.031952433825185, - "variable": "0_w[3]" - }, - { - "coefficient": 7.165952433825185, - "variable": "0_wr[(2, 3)]" - }, - { - "coefficient": -1.070955528571676, - "variable": "0_wi[(2, 3)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c161", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.4978494338705233, - "variable": "0_w[24]" - }, - { - "coefficient": 1.4978494338705233, - "variable": "0_wr[(24, 25)]" - }, - { - "coefficient": -2.868957761798156, - "variable": "0_wi[(24, 25)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(27, 24, 25)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c162", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.866907761798156, - "variable": "0_w[24]" - }, - { - "coefficient": 2.868957761798156, - "variable": "0_wr[(24, 25)]" - }, - { - "coefficient": 1.4978494338705233, - "variable": "0_wi[(24, 25)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(27, 24, 25)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c163", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.4978494338705233, - "variable": "0_w[25]" - }, - { - "coefficient": 1.4978494338705233, - "variable": "0_wr[(24, 25)]" - }, - { - "coefficient": 2.868957761798156, - "variable": "0_wi[(24, 25)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(27, 25, 24)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c164", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.866907761798156, - "variable": "0_w[25]" - }, - { - "coefficient": 2.868957761798156, - "variable": "0_wr[(24, 25)]" - }, - { - "coefficient": -1.4978494338705233, - "variable": "0_wi[(24, 25)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(27, 25, 24)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c165", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.26161249681590054, - "variable": "0_w[18]" - }, - { - "coefficient": 0.26161249681590054, - "variable": "0_wr[(18, 16)]" - }, - { - "coefficient": -11.73125512037617, - "variable": "0_wi[(18, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(21, 18, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c166", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -11.73125512037617, - "variable": "0_w[18]" - }, - { - "coefficient": 11.73125512037617, - "variable": "0_wr[(18, 16)]" - }, - { - "coefficient": 0.26161249681590054, - "variable": "0_wi[(18, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(21, 18, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c167", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.26161249681590054, - "variable": "0_w[16]" - }, - { - "coefficient": 0.26161249681590054, - "variable": "0_wr[(18, 16)]" - }, - { - "coefficient": 11.73125512037617, - "variable": "0_wi[(18, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(21, 16, 18)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c168", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -11.73125512037617, - "variable": "0_w[16]" - }, - { - "coefficient": 11.73125512037617, - "variable": "0_wr[(18, 16)]" - }, - { - "coefficient": -0.26161249681590054, - "variable": "0_wi[(18, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(21, 16, 18)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c169", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.9263284811715553, - "variable": "0_w[23]" - }, - { - "coefficient": 2.9263284811715553, - "variable": "0_wr[(23, 24)]" - }, - { - "coefficient": -5.604798539074481, - "variable": "0_wi[(23, 24)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(26, 23, 24)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c170", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -5.603748539074481, - "variable": "0_w[23]" - }, - { - "coefficient": 5.604798539074481, - "variable": "0_wr[(23, 24)]" - }, - { - "coefficient": 2.9263284811715553, - "variable": "0_wi[(23, 24)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(26, 23, 24)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c171", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.9263284811715553, - "variable": "0_w[24]" - }, - { - "coefficient": 2.9263284811715553, - "variable": "0_wr[(23, 24)]" - }, - { - "coefficient": 5.604798539074481, - "variable": "0_wi[(23, 24)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(26, 24, 23)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c172", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -5.603748539074481, - "variable": "0_w[24]" - }, - { - "coefficient": 5.604798539074481, - "variable": "0_wr[(23, 24)]" - }, - { - "coefficient": -2.9263284811715553, - "variable": "0_wi[(23, 24)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(26, 24, 23)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c173", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.450918029773461, - "variable": "0_w[8]" - }, - { - "coefficient": 2.450918029773461, - "variable": "0_wr[(8, 9)]" - }, - { - "coefficient": -6.776372942488066, - "variable": "0_wi[(8, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(10, 8, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c174", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -6.768172942488065, - "variable": "0_w[8]" - }, - { - "coefficient": 6.776372942488066, - "variable": "0_wr[(8, 9)]" - }, - { - "coefficient": 2.450918029773461, - "variable": "0_wi[(8, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(10, 8, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c175", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.450918029773461, - "variable": "0_w[9]" - }, - { - "coefficient": 2.450918029773461, - "variable": "0_wr[(8, 9)]" - }, - { - "coefficient": 6.776372942488066, - "variable": "0_wi[(8, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(10, 9, 8)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c176", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -6.768172942488065, - "variable": "0_w[9]" - }, - { - "coefficient": 6.776372942488066, - "variable": "0_wr[(8, 9)]" - }, - { - "coefficient": -2.450918029773461, - "variable": "0_wi[(8, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(10, 9, 8)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c177", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.9733135131308841, - "variable": "0_w[14]" - }, - { - "coefficient": 0.9733135131308841, - "variable": "0_wr[(14, 20)]" - }, - { - "coefficient": -2.875699016068521, - "variable": "0_wi[(14, 20)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(18, 14, 20)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c178", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.8582990160685213, - "variable": "0_w[14]" - }, - { - "coefficient": 2.875699016068521, - "variable": "0_wr[(14, 20)]" - }, - { - "coefficient": 0.9733135131308841, - "variable": "0_wi[(14, 20)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(18, 14, 20)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c179", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.9733135131308841, - "variable": "0_w[20]" - }, - { - "coefficient": 0.9733135131308841, - "variable": "0_wr[(14, 20)]" - }, - { - "coefficient": 2.875699016068521, - "variable": "0_wi[(14, 20)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(18, 20, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c180", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.8582990160685213, - "variable": "0_w[20]" - }, - { - "coefficient": 2.875699016068521, - "variable": "0_wr[(14, 20)]" - }, - { - "coefficient": -0.9733135131308841, - "variable": "0_wi[(14, 20)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(18, 20, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[1]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[1]" - }, - { - "coefficient": -0.0036, - "variable": "outflow[2]" - }, - { - "coefficient": 1.0, - "variable": "spill[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[2]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[2]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[2]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[2]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[2]" - }, - { - "coefficient": 1.0, - "variable": "spill[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[3]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[3]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[3]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[3]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[3]" - }, - { - "coefficient": 1.0, - "variable": "spill[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[4]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[4]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[4]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[4]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[4]" - }, - { - "coefficient": 1.0, - "variable": "spill[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[5]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[5]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[5]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[5]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[5]" - }, - { - "coefficient": 1.0, - "variable": "spill[5]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[6]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[6]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[6]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[6]_out" - }, - { - "coefficient": -0.0036, - "variable": "outflow[5]" - }, - { - "coefficient": 0.0036, - "variable": "outflow[6]" - }, - { - "coefficient": -1.0, - "variable": "spill[5]" - }, - { - "coefficient": 1.0, - "variable": "spill[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[7]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[7]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[7]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[7]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[7]" - }, - { - "coefficient": 1.0, - "variable": "spill[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[8]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[8]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[8]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[8]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[8]" - }, - { - "coefficient": 1.0, - "variable": "spill[8]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[9]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[9]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[9]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[9]_out" - }, - { - "coefficient": -0.0036, - "variable": "outflow[8]" - }, - { - "coefficient": 0.0036, - "variable": "outflow[9]" - }, - { - "coefficient": -1.0, - "variable": "spill[8]" - }, - { - "coefficient": 1.0, - "variable": "spill[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[10]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[10]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[10]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[10]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[10]" - }, - { - "coefficient": 1.0, - "variable": "spill[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[11]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[11]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[11]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[11]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[11]" - }, - { - "coefficient": 1.0, - "variable": "spill[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[1]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[24]" - }, - { - "coefficient": -6.9953, - "variable": "outflow[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[2]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[25]" - }, - { - "coefficient": -5.117, - "variable": "outflow[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[3]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[26]" - }, - { - "coefficient": -9.677, - "variable": "outflow[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[4]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[27]" - }, - { - "coefficient": -5.06, - "variable": "outflow[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[5]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[28]" - }, - { - "coefficient": -8.11, - "variable": "outflow[5]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[6]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[29]" - }, - { - "coefficient": -6.35, - "variable": "outflow[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[7]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[30]" - }, - { - "coefficient": -3.2, - "variable": "outflow[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[8]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[31]" - }, - { - "coefficient": -4.81, - "variable": "outflow[8]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[9]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[32]" - }, - { - "coefficient": -4.47, - "variable": "outflow[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[10]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[33]" - }, - { - "coefficient": -1.2, - "variable": "outflow[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[11]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[34]" - }, - { - "coefficient": -2.5, - "variable": "outflow[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c1_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(5, 6)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(5, 6)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c2_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[5]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[6]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(5, 6)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c3_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[5]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[6]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(5, 6)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c4_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(13, 14)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(13, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c5_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[14]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[13]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(13, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c6_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[14]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[13]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(13, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c7_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(16, 17)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(16, 17)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c8_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[16]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[17]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(16, 17)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c9_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[16]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[17]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(16, 17)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c10_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(9, 12)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(9, 12)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c11_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[12]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[9]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(9, 12)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c12_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[12]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[9]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(9, 12)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c13_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(21, 22)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(21, 22)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c14_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[22]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[21]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(21, 22)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c15_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[22]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[21]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(21, 22)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c16_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(25, 26)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(25, 26)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c17_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[25]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[26]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(25, 26)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c18_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[25]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[26]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(25, 26)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c19_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(7, 8)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(7, 8)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c20_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[8]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[7]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(7, 8)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c21_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[8]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[7]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(7, 8)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c22_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(14, 15)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(14, 15)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c23_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[14]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[15]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(14, 15)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c24_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[14]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[15]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(14, 15)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c25_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(19, 28)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c26_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[28]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[19]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(19, 28)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c27_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[28]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[19]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(19, 28)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c28_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(2, 1)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(2, 1)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c29_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[1]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[2]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(2, 1)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c30_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[1]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[2]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(2, 1)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c31_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(20, 21)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(20, 21)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c32_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[20]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[21]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(20, 21)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c33_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[20]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[21]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(20, 21)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c34_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(16, 19)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(16, 19)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c35_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[16]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[19]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(16, 19)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c36_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[16]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[19]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(16, 19)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c37_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(14, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(14, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c38_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[16]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[14]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(14, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c39_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[16]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[14]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(14, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c40_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(5, 11)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(5, 11)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c41_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[5]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[11]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(5, 11)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c42_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[5]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[11]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(5, 11)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c43_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(9, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(9, 10)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c44_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[9]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[10]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(9, 10)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c45_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[9]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[10]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(9, 10)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c46_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(7, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(7, 10)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c47_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[7]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[10]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(7, 10)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c48_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[7]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[10]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(7, 10)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c49_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(11, 18)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(11, 18)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c50_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[11]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[18]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(11, 18)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c51_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[11]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[18]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(11, 18)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c52_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(3, 4)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(3, 4)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c53_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[3]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[4]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(3, 4)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c54_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[3]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[4]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(3, 4)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c55_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(17, 27)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(17, 27)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c56_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[17]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[27]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(17, 27)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c57_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[17]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[27]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(17, 27)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c58_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(6, 7)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(6, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c59_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[6]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[7]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(6, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c60_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[6]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[7]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(6, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c61_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(22, 23)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(22, 23)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c62_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[23]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[22]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(22, 23)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c63_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[23]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[22]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(22, 23)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c64_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(4, 5)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(4, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c65_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[5]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[4]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(4, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c66_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[5]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[4]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(4, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c67_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(9, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(9, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c68_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[16]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[9]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(9, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c69_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[16]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[9]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(9, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c70_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(12, 13)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(12, 13)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c71_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[12]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[13]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(12, 13)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c72_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[12]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[13]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(12, 13)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c73_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(2, 3)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(2, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c74_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[3]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[2]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(2, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c75_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[3]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[2]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(2, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c76_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(24, 25)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(24, 25)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c77_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[24]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[25]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(24, 25)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c78_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[24]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[25]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(24, 25)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c79_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(18, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(18, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c80_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[16]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[18]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(18, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c81_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[16]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[18]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(18, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c82_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(23, 24)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(23, 24)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c83_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[24]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[23]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(23, 24)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c84_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[24]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[23]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(23, 24)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c85_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(8, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(8, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c86_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[8]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[9]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(8, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c87_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[8]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[9]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(8, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c88_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(14, 20)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(14, 20)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c89_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[20]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[14]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(14, 20)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c90_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[20]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[14]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(14, 20)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "min_volume_violation_bound[1]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[1]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[2]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[2]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[3]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[3]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[4]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[4]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[5]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[5]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[5]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[6]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[6]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[7]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[7]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[8]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[8]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[8]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[9]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[9]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[10]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[10]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[11]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[11]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[1]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[2]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[2]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[3]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[3]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[4]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[4]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[5]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[5]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[5]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[6]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[6]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[7]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[7]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[8]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[8]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[8]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[9]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[9]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[10]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[10]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[11]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[11]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c1_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(5, 6)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(5, 6)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c2_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(13, 14)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(13, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c3_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(16, 17)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(16, 17)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c4_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(9, 12)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(9, 12)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c5_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(21, 22)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(21, 22)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c6_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(25, 26)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(25, 26)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c7_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(7, 8)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(7, 8)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c8_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(14, 15)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(14, 15)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c9_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(19, 28)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c10_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(2, 1)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(2, 1)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c11_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(20, 21)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(20, 21)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c12_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(16, 19)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(16, 19)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c13_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(14, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(14, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c14_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(5, 11)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(5, 11)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c15_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(9, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(9, 10)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c16_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(7, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(7, 10)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c17_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(11, 18)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(11, 18)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c18_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(3, 4)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(3, 4)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c19_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(17, 27)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(17, 27)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c20_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(6, 7)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(6, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c21_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(22, 23)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(22, 23)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c22_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(4, 5)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(4, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c23_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(9, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(9, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c24_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(12, 13)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(12, 13)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c25_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(2, 3)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(2, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c26_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(24, 25)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(24, 25)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c27_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(18, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(18, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c28_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(23, 24)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(23, 24)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c29_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(8, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(8, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c30_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(14, 20)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(14, 20)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c1_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(5, 5, 6)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(5, 5, 6)]" - } - } - ], - "constants": [ - 0.7, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c2_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(5, 6, 5)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(5, 6, 5)]" - } - } - ], - "constants": [ - 0.7, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c3_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(16, 13, 14)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(16, 13, 14)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c4_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(16, 14, 13)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(16, 14, 13)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c5_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(20, 16, 17)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(20, 16, 17)]" - } - } - ], - "constants": [ - 0.25, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c6_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(20, 17, 16)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(20, 17, 16)]" - } - } - ], - "constants": [ - 0.25, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c7_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(12, 9, 12)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(12, 9, 12)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c8_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(12, 12, 9)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(12, 12, 9)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c9_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(24, 21, 22)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(24, 21, 22)]" - } - } - ], - "constants": [ - 0.25, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c10_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(24, 22, 21)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(24, 22, 21)]" - } - } - ], - "constants": [ - 0.25, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c11_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(28, 25, 26)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(28, 25, 26)]" - } - } - ], - "constants": [ - 0.13, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c12_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(28, 26, 25)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(28, 26, 25)]" - } - } - ], - "constants": [ - 0.13, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c13_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(8, 7, 8)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(8, 7, 8)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c14_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(8, 8, 7)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(8, 8, 7)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c15_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(17, 14, 15)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(17, 14, 15)]" - } - } - ], - "constants": [ - 0.5, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c16_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(17, 15, 14)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(17, 15, 14)]" - } - } - ], - "constants": [ - 0.5, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c17_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(30, 19, 28)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(30, 19, 28)]" - } - } - ], - "constants": [ - 1.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c18_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(30, 28, 19)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(30, 28, 19)]" - } - } - ], - "constants": [ - 1.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c19_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(1, 2, 1)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(1, 2, 1)]" - } - } - ], - "constants": [ - 0.7, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c20_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 2)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 2)]" - } - } - ], - "constants": [ - 0.7, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c21_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(23, 20, 21)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(23, 20, 21)]" - } - } - ], - "constants": [ - 0.47, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c22_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(23, 21, 20)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(23, 21, 20)]" - } - } - ], - "constants": [ - 0.47, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c23_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(22, 16, 19)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(22, 16, 19)]" - } - } - ], - "constants": [ - 1.06, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c24_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(22, 19, 16)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(22, 19, 16)]" - } - } - ], - "constants": [ - 1.06, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c25_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(19, 14, 16)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(19, 14, 16)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c26_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(19, 16, 14)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(19, 16, 14)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c27_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(6, 5, 11)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(6, 5, 11)]" - } - } - ], - "constants": [ - 1.3, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c28_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(6, 11, 5)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(6, 11, 5)]" - } - } - ], - "constants": [ - 1.3, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c29_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(11, 9, 10)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(11, 9, 10)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c30_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(11, 10, 9)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(11, 10, 9)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c31_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(31, 19, 28)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(31, 19, 28)]" - } - } - ], - "constants": [ - 1.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c32_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(31, 28, 19)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(31, 28, 19)]" - } - } - ], - "constants": [ - 1.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c33_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(9, 7, 10)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(9, 7, 10)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c34_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(9, 10, 7)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(9, 10, 7)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c35_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(14, 11, 18)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(14, 11, 18)]" - } - } - ], - "constants": [ - 1.3, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c36_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(14, 18, 11)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(14, 18, 11)]" - } - } - ], - "constants": [ - 1.3, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c37_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(3, 3, 4)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(3, 3, 4)]" - } - } - ], - "constants": [ - 1.3, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c38_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(3, 4, 3)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(3, 4, 3)]" - } - } - ], - "constants": [ - 1.3, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c39_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(29, 17, 27)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(29, 17, 27)]" - } - } - ], - "constants": [ - 2.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c40_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(29, 27, 17)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(29, 27, 17)]" - } - } - ], - "constants": [ - 2.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c41_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(7, 6, 7)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(7, 6, 7)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c42_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(7, 7, 6)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(7, 7, 6)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c43_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(25, 22, 23)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(25, 22, 23)]" - } - } - ], - "constants": [ - 0.33, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c44_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(25, 23, 22)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(25, 23, 22)]" - } - } - ], - "constants": [ - 0.33, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c45_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(4, 4, 5)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(4, 4, 5)]" - } - } - ], - "constants": [ - 1.3, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c46_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(4, 5, 4)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(4, 5, 4)]" - } - } - ], - "constants": [ - 1.3, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c47_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(13, 9, 16)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(13, 9, 16)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c48_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(13, 16, 9)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(13, 16, 9)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c49_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(15, 12, 13)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(15, 12, 13)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c50_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(15, 13, 12)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(15, 13, 12)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c51_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]" - } - } - ], - "constants": [ - 1.3, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c52_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]" - } - } - ], - "constants": [ - 1.3, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c53_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(27, 24, 25)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(27, 24, 25)]" - } - } - ], - "constants": [ - 0.13, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c54_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(27, 25, 24)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(27, 25, 24)]" - } - } - ], - "constants": [ - 0.13, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c55_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(21, 18, 16)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(21, 18, 16)]" - } - } - ], - "constants": [ - 1.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c56_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(21, 16, 18)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(21, 16, 18)]" - } - } - ], - "constants": [ - 1.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c57_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(26, 23, 24)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(26, 23, 24)]" - } - } - ], - "constants": [ - 0.13, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c58_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(26, 24, 23)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(26, 24, 23)]" - } - } - ], - "constants": [ - 0.13, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c59_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(10, 8, 9)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(10, 8, 9)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c60_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(10, 9, 8)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(10, 9, 8)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c61_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(18, 14, 20)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(18, 14, 20)]" - } - } - ], - "constants": [ - 0.47, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c62_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(18, 20, 14)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(18, 20, 14)]" - } - } - ], - "constants": [ - 0.47, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c1_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[18]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[16]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(18, 16)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(18, 16)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c2_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[19]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[28]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(19, 28)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(19, 28)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c3_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[11]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[18]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(11, 18)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(11, 18)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c4_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[4]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[5]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(4, 5)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(4, 5)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c5_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[23]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[24]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(23, 24)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(23, 24)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c6_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[12]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[13]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(12, 13)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(12, 13)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c7_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[9]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[10]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(9, 10)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(9, 10)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c8_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[9]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[12]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(9, 12)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(9, 12)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c9_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[25]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[26]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(25, 26)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(25, 26)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c10_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[7]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[8]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(7, 8)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(7, 8)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c11_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[21]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[22]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(21, 22)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(21, 22)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c12_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[5]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[11]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(5, 11)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(5, 11)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c13_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[14]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[15]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(14, 15)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(14, 15)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c14_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[7]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[10]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(7, 10)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(7, 10)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c15_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[8]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[9]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(8, 9)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(8, 9)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c16_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[5]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[6]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(5, 6)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(5, 6)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c17_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[2]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[1]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(2, 1)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(2, 1)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c18_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[3]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[4]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(3, 4)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(3, 4)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c19_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[9]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[16]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(9, 16)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(9, 16)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c20_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[14]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[20]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(14, 20)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(14, 20)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c21_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[16]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[19]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(16, 19)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(16, 19)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c22_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[14]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[16]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(14, 16)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(14, 16)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c23_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[2]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[3]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(2, 3)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(2, 3)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c24_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[16]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[17]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(16, 17)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(16, 17)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c25_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[24]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[25]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(24, 25)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(24, 25)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c26_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[13]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[14]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(13, 14)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(13, 14)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c27_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[22]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[23]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(22, 23)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(22, 23)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c28_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[6]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[7]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(6, 7)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(6, 7)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c29_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[20]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[21]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(20, 21)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(20, 21)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c30_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[17]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[27]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(17, 27)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(17, 27)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[2]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[3]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[4]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[5]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[6]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[7]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[8]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[9]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[10]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[11]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[1]" - }, - "set": { - "type": "EqualTo", - "value": 0.9398527488038416 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[2]" - }, - "set": { - "type": "EqualTo", - "value": 5.882002148039282 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[3]" - }, - "set": { - "type": "EqualTo", - "value": 0.2000144671649994 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[4]" - }, - "set": { - "type": "EqualTo", - "value": 3.9469358129786256 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[5]" - }, - "set": { - "type": "EqualTo", - "value": 6.211844156821933 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[6]" - }, - "set": { - "type": "EqualTo", - "value": 10.23842397764487 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[7]" - }, - "set": { - "type": "EqualTo", - "value": 0.1869794681093533 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[8]" - }, - "set": { - "type": "EqualTo", - "value": 10.477704945568126 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[9]" - }, - "set": { - "type": "EqualTo", - "value": 8.449733976255288 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[10]" - }, - "set": { - "type": "EqualTo", - "value": 1.4824946743419087 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[11]" - }, - "set": { - "type": "EqualTo", - "value": 3.37887731734589 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[16]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[20]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[12]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[24]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[28]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[17]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[23]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[22]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[19]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[14]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[25]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[13]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[15]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[27]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[21]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[26]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[18]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(18, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(19, 28)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(11, 18)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(4, 5)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(23, 24)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(12, 13)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(9, 10)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(9, 12)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(25, 26)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(7, 8)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(21, 22)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(5, 11)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(14, 15)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(7, 10)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(8, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(5, 6)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(2, 1)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(3, 4)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(9, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(14, 20)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(16, 19)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(14, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(2, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(16, 17)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(24, 25)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(13, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(22, 23)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(6, 7)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(20, 21)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(17, 27)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(18, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(19, 28)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(11, 18)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(4, 5)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(23, 24)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(12, 13)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(9, 10)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(9, 12)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(25, 26)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(7, 8)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(21, 22)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(5, 11)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(14, 15)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(7, 10)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(8, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(5, 6)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(2, 1)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(3, 4)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(9, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(14, 20)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(16, 19)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(14, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(2, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(16, 17)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(24, 25)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(13, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(22, 23)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(6, 7)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(20, 21)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(17, 27)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[16]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[20]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[12]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[24]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[28]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[17]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[30]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[23]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[32]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[22]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[19]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[31]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[14]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[29]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[33]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[25]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[34]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[13]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[15]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[27]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[21]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[26]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[18]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[5]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[16]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[20]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[12]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[24]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[28]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[8]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[17]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[30]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[23]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[32]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[22]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[6]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[19]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[11]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[31]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[9]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[14]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[29]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[33]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[25]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[7]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[34]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[4]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[13]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[15]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[27]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[21]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[26]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[10]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[18]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(5, 5, 6)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(16, 13, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(20, 16, 17)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(12, 9, 12)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(24, 21, 22)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(28, 25, 26)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(8, 7, 8)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(17, 14, 15)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(30, 19, 28)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 2, 1)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(23, 20, 21)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(22, 16, 19)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(19, 14, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(6, 5, 11)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(11, 9, 10)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(31, 19, 28)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(9, 7, 10)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(14, 11, 18)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 3, 4)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(29, 17, 27)]" - }, - "set": { - "type": "GreaterThan", - "lower": -2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(7, 6, 7)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(25, 22, 23)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(4, 4, 5)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(13, 9, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(15, 12, 13)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(27, 24, 25)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(21, 18, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(26, 23, 24)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(10, 8, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(18, 14, 20)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(5, 6, 5)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(16, 14, 13)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(20, 17, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(12, 12, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(24, 22, 21)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(28, 26, 25)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(8, 8, 7)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(17, 15, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(30, 28, 19)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 2)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(23, 21, 20)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(22, 19, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(19, 16, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(6, 11, 5)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(11, 10, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(31, 28, 19)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(9, 10, 7)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(14, 18, 11)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 4, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(29, 27, 17)]" - }, - "set": { - "type": "GreaterThan", - "lower": -2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(7, 7, 6)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(25, 23, 22)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(4, 5, 4)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(13, 16, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(15, 13, 12)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(27, 25, 24)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(21, 16, 18)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(26, 24, 23)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(10, 9, 8)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(18, 20, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(5, 5, 6)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(16, 13, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(20, 16, 17)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(12, 9, 12)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(24, 21, 22)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(28, 25, 26)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(8, 7, 8)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(17, 14, 15)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(30, 19, 28)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 2, 1)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(23, 20, 21)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(22, 16, 19)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(19, 14, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(6, 5, 11)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(11, 9, 10)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(31, 19, 28)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(9, 7, 10)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(14, 11, 18)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 3, 4)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(29, 17, 27)]" - }, - "set": { - "type": "GreaterThan", - "lower": -2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(7, 6, 7)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(25, 22, 23)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(4, 4, 5)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(13, 9, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(15, 12, 13)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(27, 24, 25)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(21, 18, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(26, 23, 24)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(10, 8, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(18, 14, 20)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(5, 6, 5)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(16, 14, 13)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(20, 17, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(12, 12, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(24, 22, 21)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(28, 26, 25)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(8, 8, 7)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(17, 15, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(30, 28, 19)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 2)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(23, 21, 20)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(22, 19, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(19, 16, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(6, 11, 5)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(11, 10, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(31, 28, 19)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(9, 10, 7)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(14, 18, 11)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 4, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(29, 27, 17)]" - }, - "set": { - "type": "GreaterThan", - "lower": -2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(7, 7, 6)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(25, 23, 22)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(4, 5, 4)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(13, 16, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(15, 13, 12)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(27, 25, 24)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(21, 16, 18)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(26, 24, 23)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(10, 9, 8)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(18, 20, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[2]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[3]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[4]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[5]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[6]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[7]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[8]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[9]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[10]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[11]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[12]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[13]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[14]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[15]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[16]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[17]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[18]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[19]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[20]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[21]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[22]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[23]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[24]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[25]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[26]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[27]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[28]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[5]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[16]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[20]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[12]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[24]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[28]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[8]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[17]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[1]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[23]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[22]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[19]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[6]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[11]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[9]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[14]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[3]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[7]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[25]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[4]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[13]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[15]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[2]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[27]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[21]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[26]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[10]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[18]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(18, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(19, 28)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(11, 18)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(4, 5)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(23, 24)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(12, 13)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(9, 10)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(9, 12)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(25, 26)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(7, 8)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(21, 22)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(5, 11)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(14, 15)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(7, 10)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(8, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(5, 6)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(2, 1)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(3, 4)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(9, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(14, 20)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(16, 19)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(14, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(2, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(16, 17)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(24, 25)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(13, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(22, 23)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(6, 7)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(20, 21)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(17, 27)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(18, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(19, 28)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(11, 18)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(4, 5)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(23, 24)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(12, 13)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(9, 10)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(9, 12)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(25, 26)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(7, 8)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(21, 22)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(5, 11)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(14, 15)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(7, 10)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(8, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(5, 6)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(2, 1)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(3, 4)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(9, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(14, 20)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(16, 19)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(14, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(2, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(16, 17)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(24, 25)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(13, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(22, 23)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(6, 7)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(20, 21)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(17, 27)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[5]" - }, - "set": { - "type": "LessThan", - "upper": 0.153 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[16]" - }, - "set": { - "type": "LessThan", - "upper": 0.149 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[20]" - }, - "set": { - "type": "LessThan", - "upper": 0.07339999999999999 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[12]" - }, - "set": { - "type": "LessThan", - "upper": 0.3381 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[24]" - }, - "set": { - "type": "LessThan", - "upper": 0.72 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[28]" - }, - "set": { - "type": "LessThan", - "upper": 0.7090000000000001 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[8]" - }, - "set": { - "type": "LessThan", - "upper": 0.1888 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[17]" - }, - "set": { - "type": "LessThan", - "upper": 0.149 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[30]" - }, - "set": { - "type": "LessThan", - "upper": 0.04 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]" - }, - "set": { - "type": "LessThan", - "upper": 0.1826 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[23]" - }, - "set": { - "type": "LessThan", - "upper": 0.10800000000000001 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[32]" - }, - "set": { - "type": "LessThan", - "upper": 0.4917 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[22]" - }, - "set": { - "type": "LessThan", - "upper": 0.1494 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[6]" - }, - "set": { - "type": "LessThan", - "upper": 0.1696 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[19]" - }, - "set": { - "type": "LessThan", - "upper": 0.07339999999999999 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[11]" - }, - "set": { - "type": "LessThan", - "upper": 0.3381 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[31]" - }, - "set": { - "type": "LessThan", - "upper": 0.3367 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[9]" - }, - "set": { - "type": "LessThan", - "upper": 0.5175 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[14]" - }, - "set": { - "type": "LessThan", - "upper": 0.4497 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]" - }, - "set": { - "type": "LessThan", - "upper": 0.1523 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[29]" - }, - "set": { - "type": "LessThan", - "upper": 1.08 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[33]" - }, - "set": { - "type": "LessThan", - "upper": 0.0101 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[25]" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[7]" - }, - "set": { - "type": "LessThan", - "upper": 0.1757 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[34]" - }, - "set": { - "type": "LessThan", - "upper": 0.081 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[4]" - }, - "set": { - "type": "LessThan", - "upper": 0.1623 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[13]" - }, - "set": { - "type": "LessThan", - "upper": 0.4497 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[15]" - }, - "set": { - "type": "LessThan", - "upper": 0.1483 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]" - }, - "set": { - "type": "LessThan", - "upper": 0.1593 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[27]" - }, - "set": { - "type": "LessThan", - "upper": 0.184 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[21]" - }, - "set": { - "type": "LessThan", - "upper": 0.1134 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[26]" - }, - "set": { - "type": "LessThan", - "upper": 0.076 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[10]" - }, - "set": { - "type": "LessThan", - "upper": 0.5175 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[18]" - }, - "set": { - "type": "LessThan", - "upper": 0.149 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[5]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[16]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[20]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[12]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[24]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[28]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[8]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[17]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[30]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[23]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[32]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[22]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[6]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[19]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[11]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[31]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[9]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[14]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[29]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[33]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[25]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[7]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[34]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[4]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[13]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[15]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[27]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[21]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[26]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[10]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[18]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(5, 5, 6)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(16, 13, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(20, 16, 17)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(12, 9, 12)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(24, 21, 22)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(28, 25, 26)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(8, 7, 8)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(17, 14, 15)]" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(30, 19, 28)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 2, 1)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(23, 20, 21)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(22, 16, 19)]" - }, - "set": { - "type": "LessThan", - "upper": 1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(19, 14, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(6, 5, 11)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(11, 9, 10)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(31, 19, 28)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(9, 7, 10)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(14, 11, 18)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 3, 4)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(29, 17, 27)]" - }, - "set": { - "type": "LessThan", - "upper": 2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(7, 6, 7)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(25, 22, 23)]" - }, - "set": { - "type": "LessThan", - "upper": 0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(4, 4, 5)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(13, 9, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(15, 12, 13)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(27, 24, 25)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(21, 18, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(26, 23, 24)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(10, 8, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(18, 14, 20)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(5, 6, 5)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(16, 14, 13)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(20, 17, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(12, 12, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(24, 22, 21)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(28, 26, 25)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(8, 8, 7)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(17, 15, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(30, 28, 19)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 2)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(23, 21, 20)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(22, 19, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(19, 16, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(6, 11, 5)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(11, 10, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(31, 28, 19)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(9, 10, 7)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(14, 18, 11)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 4, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(29, 27, 17)]" - }, - "set": { - "type": "LessThan", - "upper": 2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(7, 7, 6)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(25, 23, 22)]" - }, - "set": { - "type": "LessThan", - "upper": 0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(4, 5, 4)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(13, 16, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(15, 13, 12)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(27, 25, 24)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(21, 16, 18)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(26, 24, 23)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(10, 9, 8)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(18, 20, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(5, 5, 6)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(16, 13, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(20, 16, 17)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(12, 9, 12)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(24, 21, 22)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(28, 25, 26)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(8, 7, 8)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(17, 14, 15)]" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(30, 19, 28)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 2, 1)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(23, 20, 21)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(22, 16, 19)]" - }, - "set": { - "type": "LessThan", - "upper": 1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(19, 14, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(6, 5, 11)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(11, 9, 10)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(31, 19, 28)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(9, 7, 10)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(14, 11, 18)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 3, 4)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(29, 17, 27)]" - }, - "set": { - "type": "LessThan", - "upper": 2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(7, 6, 7)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(25, 22, 23)]" - }, - "set": { - "type": "LessThan", - "upper": 0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(4, 4, 5)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(13, 9, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(15, 12, 13)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(27, 24, 25)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(21, 18, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(26, 23, 24)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(10, 8, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(18, 14, 20)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(5, 6, 5)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(16, 14, 13)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(20, 17, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(12, 12, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(24, 22, 21)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(28, 26, 25)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(8, 8, 7)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(17, 15, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(30, 28, 19)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 2)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(23, 21, 20)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(22, 19, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(19, 16, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(6, 11, 5)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(11, 10, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(31, 28, 19)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(9, 10, 7)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(14, 18, 11)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 4, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(29, 27, 17)]" - }, - "set": { - "type": "LessThan", - "upper": 2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(7, 7, 6)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(25, 23, 22)]" - }, - "set": { - "type": "LessThan", - "upper": 0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(4, 5, 4)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(13, 16, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(15, 13, 12)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(27, 25, 24)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(21, 16, 18)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(26, 24, 23)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(10, 9, 8)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(18, 20, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.1 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[2]_out" - }, - "set": { - "type": "LessThan", - "upper": 137.99 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[3]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.042 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[4]_out" - }, - "set": { - "type": "LessThan", - "upper": 16.76 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[5]_out" - }, - "set": { - "type": "LessThan", - "upper": 10.35 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[6]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.32 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[7]_out" - }, - "set": { - "type": "LessThan", - "upper": 9.72 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[8]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.07 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[9]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.04 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[10]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[11]_out" - }, - "set": { - "type": "LessThan", - "upper": 2.93 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]" - }, - "set": { - "type": "LessThan", - "upper": 10.2926 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[2]" - }, - "set": { - "type": "LessThan", - "upper": 10.5531 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[3]" - }, - "set": { - "type": "LessThan", - "upper": 0.7854 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[4]" - }, - "set": { - "type": "LessThan", - "upper": 3.63 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[5]" - }, - "set": { - "type": "LessThan", - "upper": 8.74 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[6]" - }, - "set": { - "type": "LessThan", - "upper": 17.01 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[7]" - }, - "set": { - "type": "LessThan", - "upper": 1.25 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[8]" - }, - "set": { - "type": "LessThan", - "upper": 7.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[9]" - }, - "set": { - "type": "LessThan", - "upper": 11.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[10]" - }, - "set": { - "type": "LessThan", - "upper": 0.84 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[11]" - }, - "set": { - "type": "LessThan", - "upper": 3.24 - } - } - ] -} +{"name":"MathOptFormat Model","version":{"major":1,"minor":7},"variables":[{"name":"0_w[5]","primal_start":1.001},{"name":"0_w[16]","primal_start":1.001},{"name":"0_w[20]","primal_start":1.001},{"name":"0_w[12]","primal_start":1.001},{"name":"0_w[24]","primal_start":1.001},{"name":"0_w[28]","primal_start":1.001},{"name":"0_w[8]","primal_start":1.001},{"name":"0_w[17]","primal_start":1.001},{"name":"0_w[1]","primal_start":1.001},{"name":"0_w[23]","primal_start":1.001},{"name":"0_w[22]","primal_start":1.001},{"name":"0_w[19]","primal_start":1.001},{"name":"0_w[6]","primal_start":1.001},{"name":"0_w[11]","primal_start":1.001},{"name":"0_w[9]","primal_start":1.001},{"name":"0_w[14]","primal_start":1.001},{"name":"0_w[3]","primal_start":1.001},{"name":"0_w[7]","primal_start":1.001},{"name":"0_w[25]","primal_start":1.001},{"name":"0_w[4]","primal_start":1.001},{"name":"0_w[13]","primal_start":1.001},{"name":"0_w[15]","primal_start":1.001},{"name":"0_w[2]","primal_start":1.001},{"name":"0_w[27]","primal_start":1.001},{"name":"0_w[21]","primal_start":1.001},{"name":"0_w[26]","primal_start":1.001},{"name":"0_w[10]","primal_start":1.001},{"name":"0_w[18]","primal_start":1.001},{"name":"0_wr[(18, 16)]","primal_start":1.0},{"name":"0_wr[(19, 28)]","primal_start":1.0},{"name":"0_wr[(11, 18)]","primal_start":1.0},{"name":"0_wr[(4, 5)]","primal_start":1.0},{"name":"0_wr[(23, 24)]","primal_start":1.0},{"name":"0_wr[(12, 13)]","primal_start":1.0},{"name":"0_wr[(9, 10)]","primal_start":1.0},{"name":"0_wr[(9, 12)]","primal_start":1.0},{"name":"0_wr[(25, 26)]","primal_start":1.0},{"name":"0_wr[(7, 8)]","primal_start":1.0},{"name":"0_wr[(21, 22)]","primal_start":1.0},{"name":"0_wr[(5, 11)]","primal_start":1.0},{"name":"0_wr[(14, 15)]","primal_start":1.0},{"name":"0_wr[(7, 10)]","primal_start":1.0},{"name":"0_wr[(8, 9)]","primal_start":1.0},{"name":"0_wr[(5, 6)]","primal_start":1.0},{"name":"0_wr[(2, 1)]","primal_start":1.0},{"name":"0_wr[(3, 4)]","primal_start":1.0},{"name":"0_wr[(9, 16)]","primal_start":1.0},{"name":"0_wr[(14, 20)]","primal_start":1.0},{"name":"0_wr[(16, 19)]","primal_start":1.0},{"name":"0_wr[(14, 16)]","primal_start":1.0},{"name":"0_wr[(2, 3)]","primal_start":1.0},{"name":"0_wr[(16, 17)]","primal_start":1.0},{"name":"0_wr[(24, 25)]","primal_start":1.0},{"name":"0_wr[(13, 14)]","primal_start":1.0},{"name":"0_wr[(22, 23)]","primal_start":1.0},{"name":"0_wr[(6, 7)]","primal_start":1.0},{"name":"0_wr[(20, 21)]","primal_start":1.0},{"name":"0_wr[(17, 27)]","primal_start":1.0},{"name":"0_wi[(18, 16)]","primal_start":0.0},{"name":"0_wi[(19, 28)]","primal_start":0.0},{"name":"0_wi[(11, 18)]","primal_start":0.0},{"name":"0_wi[(4, 5)]","primal_start":0.0},{"name":"0_wi[(23, 24)]","primal_start":0.0},{"name":"0_wi[(12, 13)]","primal_start":0.0},{"name":"0_wi[(9, 10)]","primal_start":0.0},{"name":"0_wi[(9, 12)]","primal_start":0.0},{"name":"0_wi[(25, 26)]","primal_start":0.0},{"name":"0_wi[(7, 8)]","primal_start":0.0},{"name":"0_wi[(21, 22)]","primal_start":0.0},{"name":"0_wi[(5, 11)]","primal_start":0.0},{"name":"0_wi[(14, 15)]","primal_start":0.0},{"name":"0_wi[(7, 10)]","primal_start":0.0},{"name":"0_wi[(8, 9)]","primal_start":0.0},{"name":"0_wi[(5, 6)]","primal_start":0.0},{"name":"0_wi[(2, 1)]","primal_start":0.0},{"name":"0_wi[(3, 4)]","primal_start":0.0},{"name":"0_wi[(9, 16)]","primal_start":0.0},{"name":"0_wi[(14, 20)]","primal_start":0.0},{"name":"0_wi[(16, 19)]","primal_start":0.0},{"name":"0_wi[(14, 16)]","primal_start":0.0},{"name":"0_wi[(2, 3)]","primal_start":0.0},{"name":"0_wi[(16, 17)]","primal_start":0.0},{"name":"0_wi[(24, 25)]","primal_start":0.0},{"name":"0_wi[(13, 14)]","primal_start":0.0},{"name":"0_wi[(22, 23)]","primal_start":0.0},{"name":"0_wi[(6, 7)]","primal_start":0.0},{"name":"0_wi[(20, 21)]","primal_start":0.0},{"name":"0_wi[(17, 27)]","primal_start":0.0},{"name":"0_pg[5]","primal_start":0.0},{"name":"0_pg[16]","primal_start":0.0},{"name":"0_pg[20]","primal_start":0.0},{"name":"0_pg[12]","primal_start":0.0},{"name":"0_pg[24]","primal_start":0.0},{"name":"0_pg[28]","primal_start":0.0},{"name":"0_pg[8]","primal_start":0.0},{"name":"0_pg[17]","primal_start":0.0},{"name":"0_pg[30]","primal_start":0.0},{"name":"0_pg[1]","primal_start":0.0},{"name":"0_pg[23]","primal_start":0.0},{"name":"0_pg[32]","primal_start":0.0},{"name":"0_pg[22]","primal_start":0.0},{"name":"0_pg[6]","primal_start":0.0},{"name":"0_pg[19]","primal_start":0.0},{"name":"0_pg[11]","primal_start":0.0},{"name":"0_pg[31]","primal_start":0.0},{"name":"0_pg[9]","primal_start":0.0},{"name":"0_pg[14]","primal_start":0.0},{"name":"0_pg[3]","primal_start":0.0},{"name":"0_pg[29]","primal_start":0.0},{"name":"0_pg[33]","primal_start":0.0},{"name":"0_pg[25]","primal_start":0.0},{"name":"0_pg[7]","primal_start":0.0},{"name":"0_pg[34]","primal_start":0.0},{"name":"0_pg[4]","primal_start":0.0},{"name":"0_pg[13]","primal_start":0.0},{"name":"0_pg[15]","primal_start":0.0},{"name":"0_pg[2]","primal_start":0.0},{"name":"0_pg[27]","primal_start":0.0},{"name":"0_pg[21]","primal_start":0.0},{"name":"0_pg[26]","primal_start":0.0},{"name":"0_pg[10]","primal_start":0.0},{"name":"0_pg[18]","primal_start":0.0},{"name":"0_qg[5]","primal_start":0.0},{"name":"0_qg[16]","primal_start":0.0},{"name":"0_qg[20]","primal_start":0.0},{"name":"0_qg[12]","primal_start":0.0},{"name":"0_qg[24]","primal_start":0.0},{"name":"0_qg[28]","primal_start":0.0},{"name":"0_qg[8]","primal_start":0.0},{"name":"0_qg[17]","primal_start":0.0},{"name":"0_qg[30]","primal_start":0.0},{"name":"0_qg[1]","primal_start":0.0},{"name":"0_qg[23]","primal_start":0.0},{"name":"0_qg[32]","primal_start":0.0},{"name":"0_qg[22]","primal_start":0.0},{"name":"0_qg[6]","primal_start":0.0},{"name":"0_qg[19]","primal_start":0.0},{"name":"0_qg[11]","primal_start":0.0},{"name":"0_qg[31]","primal_start":0.0},{"name":"0_qg[9]","primal_start":0.0},{"name":"0_qg[14]","primal_start":0.0},{"name":"0_qg[3]","primal_start":0.0},{"name":"0_qg[29]","primal_start":0.0},{"name":"0_qg[33]","primal_start":0.0},{"name":"0_qg[25]","primal_start":0.0},{"name":"0_qg[7]","primal_start":0.0},{"name":"0_qg[34]","primal_start":0.0},{"name":"0_qg[4]","primal_start":0.0},{"name":"0_qg[13]","primal_start":0.0},{"name":"0_qg[15]","primal_start":0.0},{"name":"0_qg[2]","primal_start":0.0},{"name":"0_qg[27]","primal_start":0.0},{"name":"0_qg[21]","primal_start":0.0},{"name":"0_qg[26]","primal_start":0.0},{"name":"0_qg[10]","primal_start":0.0},{"name":"0_qg[18]","primal_start":0.0},{"name":"0_p[(5, 5, 6)]","primal_start":0.0},{"name":"0_p[(16, 13, 14)]","primal_start":0.0},{"name":"0_p[(20, 16, 17)]","primal_start":0.0},{"name":"0_p[(12, 9, 12)]","primal_start":0.0},{"name":"0_p[(24, 21, 22)]","primal_start":0.0},{"name":"0_p[(28, 25, 26)]","primal_start":0.0},{"name":"0_p[(8, 7, 8)]","primal_start":0.0},{"name":"0_p[(17, 14, 15)]","primal_start":0.0},{"name":"0_p[(30, 19, 28)]","primal_start":0.0},{"name":"0_p[(1, 2, 1)]","primal_start":0.0},{"name":"0_p[(23, 20, 21)]","primal_start":0.0},{"name":"0_p[(22, 16, 19)]","primal_start":0.0},{"name":"0_p[(19, 14, 16)]","primal_start":0.0},{"name":"0_p[(6, 5, 11)]","primal_start":0.0},{"name":"0_p[(11, 9, 10)]","primal_start":0.0},{"name":"0_p[(31, 19, 28)]","primal_start":0.0},{"name":"0_p[(9, 7, 10)]","primal_start":0.0},{"name":"0_p[(14, 11, 18)]","primal_start":0.0},{"name":"0_p[(3, 3, 4)]","primal_start":0.0},{"name":"0_p[(29, 17, 27)]","primal_start":0.0},{"name":"0_p[(7, 6, 7)]","primal_start":0.0},{"name":"0_p[(25, 22, 23)]","primal_start":0.0},{"name":"0_p[(4, 4, 5)]","primal_start":0.0},{"name":"0_p[(13, 9, 16)]","primal_start":0.0},{"name":"0_p[(15, 12, 13)]","primal_start":0.0},{"name":"0_p[(2, 2, 3)]","primal_start":0.0},{"name":"0_p[(27, 24, 25)]","primal_start":0.0},{"name":"0_p[(21, 18, 16)]","primal_start":0.0},{"name":"0_p[(26, 23, 24)]","primal_start":0.0},{"name":"0_p[(10, 8, 9)]","primal_start":0.0},{"name":"0_p[(18, 14, 20)]","primal_start":0.0},{"name":"0_p[(5, 6, 5)]","primal_start":0.0},{"name":"0_p[(16, 14, 13)]","primal_start":0.0},{"name":"0_p[(20, 17, 16)]","primal_start":0.0},{"name":"0_p[(12, 12, 9)]","primal_start":0.0},{"name":"0_p[(24, 22, 21)]","primal_start":0.0},{"name":"0_p[(28, 26, 25)]","primal_start":0.0},{"name":"0_p[(8, 8, 7)]","primal_start":0.0},{"name":"0_p[(17, 15, 14)]","primal_start":0.0},{"name":"0_p[(30, 28, 19)]","primal_start":0.0},{"name":"0_p[(1, 1, 2)]","primal_start":0.0},{"name":"0_p[(23, 21, 20)]","primal_start":0.0},{"name":"0_p[(22, 19, 16)]","primal_start":0.0},{"name":"0_p[(19, 16, 14)]","primal_start":0.0},{"name":"0_p[(6, 11, 5)]","primal_start":0.0},{"name":"0_p[(11, 10, 9)]","primal_start":0.0},{"name":"0_p[(31, 28, 19)]","primal_start":0.0},{"name":"0_p[(9, 10, 7)]","primal_start":0.0},{"name":"0_p[(14, 18, 11)]","primal_start":0.0},{"name":"0_p[(3, 4, 3)]","primal_start":0.0},{"name":"0_p[(29, 27, 17)]","primal_start":0.0},{"name":"0_p[(7, 7, 6)]","primal_start":0.0},{"name":"0_p[(25, 23, 22)]","primal_start":0.0},{"name":"0_p[(4, 5, 4)]","primal_start":0.0},{"name":"0_p[(13, 16, 9)]","primal_start":0.0},{"name":"0_p[(15, 13, 12)]","primal_start":0.0},{"name":"0_p[(2, 3, 2)]","primal_start":0.0},{"name":"0_p[(27, 25, 24)]","primal_start":0.0},{"name":"0_p[(21, 16, 18)]","primal_start":0.0},{"name":"0_p[(26, 24, 23)]","primal_start":0.0},{"name":"0_p[(10, 9, 8)]","primal_start":0.0},{"name":"0_p[(18, 20, 14)]","primal_start":0.0},{"name":"0_q[(5, 5, 6)]","primal_start":0.0},{"name":"0_q[(16, 13, 14)]","primal_start":0.0},{"name":"0_q[(20, 16, 17)]","primal_start":0.0},{"name":"0_q[(12, 9, 12)]","primal_start":0.0},{"name":"0_q[(24, 21, 22)]","primal_start":0.0},{"name":"0_q[(28, 25, 26)]","primal_start":0.0},{"name":"0_q[(8, 7, 8)]","primal_start":0.0},{"name":"0_q[(17, 14, 15)]","primal_start":0.0},{"name":"0_q[(30, 19, 28)]","primal_start":0.0},{"name":"0_q[(1, 2, 1)]","primal_start":0.0},{"name":"0_q[(23, 20, 21)]","primal_start":0.0},{"name":"0_q[(22, 16, 19)]","primal_start":0.0},{"name":"0_q[(19, 14, 16)]","primal_start":0.0},{"name":"0_q[(6, 5, 11)]","primal_start":0.0},{"name":"0_q[(11, 9, 10)]","primal_start":0.0},{"name":"0_q[(31, 19, 28)]","primal_start":0.0},{"name":"0_q[(9, 7, 10)]","primal_start":0.0},{"name":"0_q[(14, 11, 18)]","primal_start":0.0},{"name":"0_q[(3, 3, 4)]","primal_start":0.0},{"name":"0_q[(29, 17, 27)]","primal_start":0.0},{"name":"0_q[(7, 6, 7)]","primal_start":0.0},{"name":"0_q[(25, 22, 23)]","primal_start":0.0},{"name":"0_q[(4, 4, 5)]","primal_start":0.0},{"name":"0_q[(13, 9, 16)]","primal_start":0.0},{"name":"0_q[(15, 12, 13)]","primal_start":0.0},{"name":"0_q[(2, 2, 3)]","primal_start":0.0},{"name":"0_q[(27, 24, 25)]","primal_start":0.0},{"name":"0_q[(21, 18, 16)]","primal_start":0.0},{"name":"0_q[(26, 23, 24)]","primal_start":0.0},{"name":"0_q[(10, 8, 9)]","primal_start":0.0},{"name":"0_q[(18, 14, 20)]","primal_start":0.0},{"name":"0_q[(5, 6, 5)]","primal_start":0.0},{"name":"0_q[(16, 14, 13)]","primal_start":0.0},{"name":"0_q[(20, 17, 16)]","primal_start":0.0},{"name":"0_q[(12, 12, 9)]","primal_start":0.0},{"name":"0_q[(24, 22, 21)]","primal_start":0.0},{"name":"0_q[(28, 26, 25)]","primal_start":0.0},{"name":"0_q[(8, 8, 7)]","primal_start":0.0},{"name":"0_q[(17, 15, 14)]","primal_start":0.0},{"name":"0_q[(30, 28, 19)]","primal_start":0.0},{"name":"0_q[(1, 1, 2)]","primal_start":0.0},{"name":"0_q[(23, 21, 20)]","primal_start":0.0},{"name":"0_q[(22, 19, 16)]","primal_start":0.0},{"name":"0_q[(19, 16, 14)]","primal_start":0.0},{"name":"0_q[(6, 11, 5)]","primal_start":0.0},{"name":"0_q[(11, 10, 9)]","primal_start":0.0},{"name":"0_q[(31, 28, 19)]","primal_start":0.0},{"name":"0_q[(9, 10, 7)]","primal_start":0.0},{"name":"0_q[(14, 18, 11)]","primal_start":0.0},{"name":"0_q[(3, 4, 3)]","primal_start":0.0},{"name":"0_q[(29, 27, 17)]","primal_start":0.0},{"name":"0_q[(7, 7, 6)]","primal_start":0.0},{"name":"0_q[(25, 23, 22)]","primal_start":0.0},{"name":"0_q[(4, 5, 4)]","primal_start":0.0},{"name":"0_q[(13, 16, 9)]","primal_start":0.0},{"name":"0_q[(15, 13, 12)]","primal_start":0.0},{"name":"0_q[(2, 3, 2)]","primal_start":0.0},{"name":"0_q[(27, 25, 24)]","primal_start":0.0},{"name":"0_q[(21, 16, 18)]","primal_start":0.0},{"name":"0_q[(26, 24, 23)]","primal_start":0.0},{"name":"0_q[(10, 9, 8)]","primal_start":0.0},{"name":"0_q[(18, 20, 14)]","primal_start":0.0},{"name":"reservoir[1]_in","primal_start":0.0},{"name":"reservoir[1]_out","primal_start":0.0},{"name":"reservoir[2]_in","primal_start":0.0},{"name":"reservoir[2]_out","primal_start":0.0},{"name":"reservoir[3]_in","primal_start":0.0},{"name":"reservoir[3]_out","primal_start":0.0},{"name":"reservoir[4]_in","primal_start":0.0},{"name":"reservoir[4]_out","primal_start":0.0},{"name":"reservoir[5]_in","primal_start":0.0},{"name":"reservoir[5]_out","primal_start":0.0},{"name":"reservoir[6]_in","primal_start":0.0},{"name":"reservoir[6]_out","primal_start":0.0},{"name":"reservoir[7]_in","primal_start":0.0},{"name":"reservoir[7]_out","primal_start":0.0},{"name":"reservoir[8]_in","primal_start":0.0},{"name":"reservoir[8]_out","primal_start":0.0},{"name":"reservoir[9]_in","primal_start":0.0},{"name":"reservoir[9]_out","primal_start":0.0},{"name":"reservoir[10]_in","primal_start":0.0},{"name":"reservoir[10]_out","primal_start":0.0},{"name":"reservoir[11]_in","primal_start":0.0},{"name":"reservoir[11]_out","primal_start":0.0},{"name":"min_volume_violation[1]","primal_start":0.0},{"name":"min_volume_violation[2]","primal_start":0.0},{"name":"min_volume_violation[3]","primal_start":0.0},{"name":"min_volume_violation[4]","primal_start":0.0},{"name":"min_volume_violation[5]","primal_start":0.0},{"name":"min_volume_violation[6]","primal_start":0.0},{"name":"min_volume_violation[7]","primal_start":0.0},{"name":"min_volume_violation[8]","primal_start":0.0},{"name":"min_volume_violation[9]","primal_start":0.0},{"name":"min_volume_violation[10]","primal_start":0.0},{"name":"min_volume_violation[11]","primal_start":0.0},{"name":"outflow[1]","primal_start":0.0},{"name":"outflow[2]","primal_start":0.0},{"name":"outflow[3]","primal_start":0.0},{"name":"outflow[4]","primal_start":0.0},{"name":"outflow[5]","primal_start":0.0},{"name":"outflow[6]","primal_start":0.0},{"name":"outflow[7]","primal_start":0.0},{"name":"outflow[8]","primal_start":0.0},{"name":"outflow[9]","primal_start":0.0},{"name":"outflow[10]","primal_start":0.0},{"name":"outflow[11]","primal_start":0.0},{"name":"spill[1]","primal_start":0.0},{"name":"spill[2]","primal_start":0.0},{"name":"spill[3]","primal_start":0.0},{"name":"spill[4]","primal_start":0.0},{"name":"spill[5]","primal_start":0.0},{"name":"spill[6]","primal_start":0.0},{"name":"spill[7]","primal_start":0.0},{"name":"spill[8]","primal_start":0.0},{"name":"spill[9]","primal_start":0.0},{"name":"spill[10]","primal_start":0.0},{"name":"spill[11]","primal_start":0.0},{"name":"min_outflow_violation[1]","primal_start":0.0},{"name":"min_outflow_violation[2]","primal_start":0.0},{"name":"min_outflow_violation[3]","primal_start":0.0},{"name":"min_outflow_violation[4]","primal_start":0.0},{"name":"min_outflow_violation[5]","primal_start":0.0},{"name":"min_outflow_violation[6]","primal_start":0.0},{"name":"min_outflow_violation[7]","primal_start":0.0},{"name":"min_outflow_violation[8]","primal_start":0.0},{"name":"min_outflow_violation[9]","primal_start":0.0},{"name":"min_outflow_violation[10]","primal_start":0.0},{"name":"min_outflow_violation[11]","primal_start":0.0},{"name":"inflow[1]","primal_start":0.0},{"name":"inflow[2]","primal_start":0.0},{"name":"inflow[3]","primal_start":0.0},{"name":"inflow[4]","primal_start":0.0},{"name":"inflow[5]","primal_start":0.0},{"name":"inflow[6]","primal_start":0.0},{"name":"inflow[7]","primal_start":0.0},{"name":"inflow[8]","primal_start":0.0},{"name":"inflow[9]","primal_start":0.0},{"name":"inflow[10]","primal_start":0.0},{"name":"inflow[11]","primal_start":0.0},{"name":"deficit[1]","primal_start":0.0},{"name":"deficit[2]","primal_start":0.0},{"name":"deficit[3]","primal_start":0.0},{"name":"deficit[4]","primal_start":0.0},{"name":"deficit[5]","primal_start":0.0},{"name":"deficit[6]","primal_start":0.0},{"name":"deficit[7]","primal_start":0.0},{"name":"deficit[8]","primal_start":0.0},{"name":"deficit[9]","primal_start":0.0},{"name":"deficit[10]","primal_start":0.0},{"name":"deficit[11]","primal_start":0.0},{"name":"deficit[12]","primal_start":0.0},{"name":"deficit[13]","primal_start":0.0},{"name":"deficit[14]","primal_start":0.0},{"name":"deficit[15]","primal_start":0.0},{"name":"deficit[16]","primal_start":0.0},{"name":"deficit[17]","primal_start":0.0},{"name":"deficit[18]","primal_start":0.0},{"name":"deficit[19]","primal_start":0.0},{"name":"deficit[20]","primal_start":0.0},{"name":"deficit[21]","primal_start":0.0},{"name":"deficit[22]","primal_start":0.0},{"name":"deficit[23]","primal_start":0.0},{"name":"deficit[24]","primal_start":0.0},{"name":"deficit[25]","primal_start":0.0},{"name":"deficit[26]","primal_start":0.0},{"name":"deficit[27]","primal_start":0.0},{"name":"deficit[28]","primal_start":0.0}],"objective":{"sense":"min","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":6000.0,"variable":"deficit[1]"},{"coefficient":6000.0,"variable":"deficit[2]"},{"coefficient":6000.0,"variable":"deficit[3]"},{"coefficient":6000.0,"variable":"deficit[4]"},{"coefficient":6000.0,"variable":"deficit[5]"},{"coefficient":6000.0,"variable":"deficit[6]"},{"coefficient":6000.0,"variable":"deficit[7]"},{"coefficient":6000.0,"variable":"deficit[8]"},{"coefficient":6000.0,"variable":"deficit[9]"},{"coefficient":6000.0,"variable":"deficit[10]"},{"coefficient":6000.0,"variable":"deficit[11]"},{"coefficient":6000.0,"variable":"deficit[12]"},{"coefficient":6000.0,"variable":"deficit[13]"},{"coefficient":6000.0,"variable":"deficit[14]"},{"coefficient":6000.0,"variable":"deficit[15]"},{"coefficient":6000.0,"variable":"deficit[16]"},{"coefficient":6000.0,"variable":"deficit[17]"},{"coefficient":6000.0,"variable":"deficit[18]"},{"coefficient":6000.0,"variable":"deficit[19]"},{"coefficient":6000.0,"variable":"deficit[20]"},{"coefficient":6000.0,"variable":"deficit[21]"},{"coefficient":6000.0,"variable":"deficit[22]"},{"coefficient":6000.0,"variable":"deficit[23]"},{"coefficient":6000.0,"variable":"deficit[24]"},{"coefficient":6000.0,"variable":"deficit[25]"},{"coefficient":6000.0,"variable":"deficit[26]"},{"coefficient":6000.0,"variable":"deficit[27]"},{"coefficient":6000.0,"variable":"deficit[28]"},{"coefficient":2268.0,"variable":"0_pg[5]"},{"coefficient":2059.0,"variable":"0_pg[16]"},{"coefficient":1780.0,"variable":"0_pg[20]"},{"coefficient":1576.0,"variable":"0_pg[12]"},{"coefficient":10.0,"variable":"0_pg[24]"},{"coefficient":10.0,"variable":"0_pg[28]"},{"coefficient":1754.0,"variable":"0_pg[8]"},{"coefficient":2059.0,"variable":"0_pg[17]"},{"coefficient":10.0,"variable":"0_pg[30]"},{"coefficient":1918.0,"variable":"0_pg[1]"},{"coefficient":4244.0,"variable":"0_pg[23]"},{"coefficient":10.0,"variable":"0_pg[32]"},{"coefficient":1517.0,"variable":"0_pg[22]"},{"coefficient":2131.0,"variable":"0_pg[6]"},{"coefficient":1780.0,"variable":"0_pg[19]"},{"coefficient":1576.0,"variable":"0_pg[11]"},{"coefficient":10.0,"variable":"0_pg[31]"},{"coefficient":1576.0,"variable":"0_pg[9]"},{"coefficient":1404.0,"variable":"0_pg[14]"},{"coefficient":2184.0,"variable":"0_pg[3]"},{"coefficient":10.0,"variable":"0_pg[29]"},{"coefficient":10.0,"variable":"0_pg[33]"},{"coefficient":10.0,"variable":"0_pg[25]"},{"coefficient":1822.0,"variable":"0_pg[7]"},{"coefficient":10.0,"variable":"0_pg[34]"},{"coefficient":2179.0,"variable":"0_pg[4]"},{"coefficient":1404.0,"variable":"0_pg[13]"},{"coefficient":2077.0,"variable":"0_pg[15]"},{"coefficient":2120.0,"variable":"0_pg[2]"},{"coefficient":10.0,"variable":"0_pg[27]"},{"coefficient":1598.0,"variable":"0_pg[21]"},{"coefficient":10.0,"variable":"0_pg[26]"},{"coefficient":1576.0,"variable":"0_pg[10]"},{"coefficient":2059.0,"variable":"0_pg[18]"}],"constant":0.0}},"constraints":[{"name":"c1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(5, 5, 6)]"},{"coefficient":1.0,"variable":"0_p[(6, 5, 11)]"},{"coefficient":1.0,"variable":"0_p[(4, 5, 4)]"},{"coefficient":-1.0,"variable":"deficit[5]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(5, 5, 6)]"},{"coefficient":1.0,"variable":"0_q[(6, 5, 11)]"},{"coefficient":1.0,"variable":"0_q[(4, 5, 4)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c3","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(20, 16, 17)]"},{"coefficient":1.0,"variable":"0_p[(22, 16, 19)]"},{"coefficient":1.0,"variable":"0_p[(19, 16, 14)]"},{"coefficient":1.0,"variable":"0_p[(13, 16, 9)]"},{"coefficient":1.0,"variable":"0_p[(21, 16, 18)]"},{"coefficient":-1.0,"variable":"deficit[16]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.21439096103324617}},{"name":"c4","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(20, 16, 17)]"},{"coefficient":1.0,"variable":"0_q[(22, 16, 19)]"},{"coefficient":1.0,"variable":"0_q[(19, 16, 14)]"},{"coefficient":1.0,"variable":"0_q[(13, 16, 9)]"},{"coefficient":1.0,"variable":"0_q[(21, 16, 18)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.02572691532398954}},{"name":"c5","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(23, 20, 21)]"},{"coefficient":1.0,"variable":"0_p[(18, 20, 14)]"},{"coefficient":-1.0,"variable":"deficit[20]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.0015565421870758504}},{"name":"c6","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(23, 20, 21)]"},{"coefficient":1.0,"variable":"0_q[(18, 20, 14)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.00018678506244910206}},{"name":"c7","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(15, 12, 13)]"},{"coefficient":1.0,"variable":"0_p[(12, 12, 9)]"},{"coefficient":-1.0,"variable":"deficit[12]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.05738794110411041}},{"name":"c8","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(15, 12, 13)]"},{"coefficient":1.0,"variable":"0_q[(12, 12, 9)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.006886552932493249}},{"name":"c9","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(27, 24, 25)]"},{"coefficient":1.0,"variable":"0_p[(26, 24, 23)]"},{"coefficient":-1.0,"variable":"deficit[24]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.01804043447630477}},{"name":"c10","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(27, 24, 25)]"},{"coefficient":1.0,"variable":"0_q[(26, 24, 23)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.0021648521371565727}},{"name":"c11","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[28]"},{"coefficient":-1.0,"variable":"0_pg[30]"},{"coefficient":-1.0,"variable":"0_pg[29]"},{"coefficient":1.0,"variable":"0_p[(30, 28, 19)]"},{"coefficient":1.0,"variable":"0_p[(31, 28, 19)]"},{"coefficient":-1.0,"variable":"deficit[28]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c12","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_qg[28]"},{"coefficient":-1.0,"variable":"0_qg[30]"},{"coefficient":-1.0,"variable":"0_qg[29]"},{"coefficient":1.0,"variable":"0_q[(30, 28, 19)]"},{"coefficient":1.0,"variable":"0_q[(31, 28, 19)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c13","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[25]"},{"coefficient":1.0,"variable":"0_p[(10, 8, 9)]"},{"coefficient":1.0,"variable":"0_p[(8, 8, 7)]"},{"coefficient":-1.0,"variable":"deficit[8]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c14","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_qg[25]"},{"coefficient":1.0,"variable":"0_q[(10, 8, 9)]"},{"coefficient":1.0,"variable":"0_q[(8, 8, 7)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c15","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(29, 17, 27)]"},{"coefficient":1.0,"variable":"0_p[(20, 17, 16)]"},{"coefficient":-1.0,"variable":"deficit[17]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.267753330934522}},{"name":"c16","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(29, 17, 27)]"},{"coefficient":1.0,"variable":"0_q[(20, 17, 16)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.03213039971214264}},{"name":"c17","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[5]"},{"coefficient":-1.0,"variable":"0_pg[8]"},{"coefficient":-1.0,"variable":"0_pg[1]"},{"coefficient":-1.0,"variable":"0_pg[6]"},{"coefficient":-1.0,"variable":"0_pg[9]"},{"coefficient":-1.0,"variable":"0_pg[3]"},{"coefficient":-1.0,"variable":"0_pg[7]"},{"coefficient":-1.0,"variable":"0_pg[4]"},{"coefficient":-1.0,"variable":"0_pg[2]"},{"coefficient":-1.0,"variable":"0_pg[10]"},{"coefficient":1.0,"variable":"0_p[(1, 1, 2)]"},{"coefficient":-1.0,"variable":"deficit[1]"}],"constant":0.0},"set":{"type":"EqualTo","value":-1.6075543555612704}},{"name":"c18","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_qg[5]"},{"coefficient":-1.0,"variable":"0_qg[8]"},{"coefficient":-1.0,"variable":"0_qg[1]"},{"coefficient":-1.0,"variable":"0_qg[6]"},{"coefficient":-1.0,"variable":"0_qg[9]"},{"coefficient":-1.0,"variable":"0_qg[3]"},{"coefficient":-1.0,"variable":"0_qg[7]"},{"coefficient":-1.0,"variable":"0_qg[4]"},{"coefficient":-1.0,"variable":"0_qg[2]"},{"coefficient":-1.0,"variable":"0_qg[10]"},{"coefficient":1.0,"variable":"0_q[(1, 1, 2)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.19290652266735245}},{"name":"c19","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[21]"},{"coefficient":1.0,"variable":"0_p[(26, 23, 24)]"},{"coefficient":1.0,"variable":"0_p[(25, 23, 22)]"},{"coefficient":-1.0,"variable":"deficit[23]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.0004825663866386638}},{"name":"c20","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_qg[21]"},{"coefficient":1.0,"variable":"0_q[(26, 23, 24)]"},{"coefficient":1.0,"variable":"0_q[(25, 23, 22)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-5.790796639663966e-5}},{"name":"c21","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[34]"},{"coefficient":1.0,"variable":"0_p[(25, 22, 23)]"},{"coefficient":1.0,"variable":"0_p[(24, 22, 21)]"},{"coefficient":-1.0,"variable":"deficit[22]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.12074817048704867}},{"name":"c22","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_qg[34]"},{"coefficient":1.0,"variable":"0_q[(25, 22, 23)]"},{"coefficient":1.0,"variable":"0_q[(24, 22, 21)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.01448978045844584}},{"name":"c23","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[20]"},{"coefficient":-1.0,"variable":"0_pg[32]"},{"coefficient":-1.0,"variable":"0_pg[19]"},{"coefficient":-1.0,"variable":"0_pg[31]"},{"coefficient":-1.0,"variable":"0_pg[33]"},{"coefficient":1.0,"variable":"0_p[(30, 19, 28)]"},{"coefficient":1.0,"variable":"0_p[(31, 19, 28)]"},{"coefficient":1.0,"variable":"0_p[(22, 19, 16)]"},{"coefficient":-1.0,"variable":"deficit[19]"}],"constant":0.0},"set":{"type":"EqualTo","value":-1.4735118986170044}},{"name":"c24","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_qg[20]"},{"coefficient":-1.0,"variable":"0_qg[32]"},{"coefficient":-1.0,"variable":"0_qg[19]"},{"coefficient":-1.0,"variable":"0_qg[31]"},{"coefficient":-1.0,"variable":"0_qg[33]"},{"coefficient":1.0,"variable":"0_q[(30, 19, 28)]"},{"coefficient":1.0,"variable":"0_q[(31, 19, 28)]"},{"coefficient":1.0,"variable":"0_q[(22, 19, 16)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.1768214278340405}},{"name":"c25","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(7, 6, 7)]"},{"coefficient":1.0,"variable":"0_p[(5, 6, 5)]"},{"coefficient":-1.0,"variable":"deficit[6]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c26","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(7, 6, 7)]"},{"coefficient":1.0,"variable":"0_q[(5, 6, 5)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c27","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(14, 11, 18)]"},{"coefficient":1.0,"variable":"0_p[(6, 11, 5)]"},{"coefficient":-1.0,"variable":"deficit[11]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c28","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(14, 11, 18)]"},{"coefficient":1.0,"variable":"0_q[(6, 11, 5)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c29","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[16]"},{"coefficient":-1.0,"variable":"0_pg[17]"},{"coefficient":-1.0,"variable":"0_pg[15]"},{"coefficient":-1.0,"variable":"0_pg[18]"},{"coefficient":1.0,"variable":"0_p[(12, 9, 12)]"},{"coefficient":1.0,"variable":"0_p[(11, 9, 10)]"},{"coefficient":1.0,"variable":"0_p[(13, 9, 16)]"},{"coefficient":1.0,"variable":"0_p[(10, 9, 8)]"},{"coefficient":-1.0,"variable":"deficit[9]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.21593913974111698}},{"name":"c30","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_qg[16]"},{"coefficient":-1.0,"variable":"0_qg[17]"},{"coefficient":-1.0,"variable":"0_qg[15]"},{"coefficient":-1.0,"variable":"0_qg[18]"},{"coefficient":1.0,"variable":"0_q[(12, 9, 12)]"},{"coefficient":1.0,"variable":"0_q[(11, 9, 10)]"},{"coefficient":1.0,"variable":"0_q[(13, 9, 16)]"},{"coefficient":1.0,"variable":"0_q[(10, 9, 8)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.025912696768934037}},{"name":"c31","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(17, 14, 15)]"},{"coefficient":1.0,"variable":"0_p[(19, 14, 16)]"},{"coefficient":1.0,"variable":"0_p[(18, 14, 20)]"},{"coefficient":1.0,"variable":"0_p[(16, 14, 13)]"},{"coefficient":-1.0,"variable":"deficit[14]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c32","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(17, 14, 15)]"},{"coefficient":1.0,"variable":"0_q[(19, 14, 16)]"},{"coefficient":1.0,"variable":"0_q[(18, 14, 20)]"},{"coefficient":1.0,"variable":"0_q[(16, 14, 13)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c33","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[12]"},{"coefficient":-1.0,"variable":"0_pg[11]"},{"coefficient":-1.0,"variable":"0_pg[14]"},{"coefficient":-1.0,"variable":"0_pg[13]"},{"coefficient":1.0,"variable":"0_p[(3, 3, 4)]"},{"coefficient":1.0,"variable":"0_p[(2, 3, 2)]"},{"coefficient":-1.0,"variable":"deficit[3]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c34","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_qg[12]"},{"coefficient":-1.0,"variable":"0_qg[11]"},{"coefficient":-1.0,"variable":"0_qg[14]"},{"coefficient":-1.0,"variable":"0_qg[13]"},{"coefficient":1.0,"variable":"0_q[(3, 3, 4)]"},{"coefficient":1.0,"variable":"0_q[(2, 3, 2)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c35","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[24]"},{"coefficient":1.0,"variable":"0_p[(8, 7, 8)]"},{"coefficient":1.0,"variable":"0_p[(9, 7, 10)]"},{"coefficient":1.0,"variable":"0_p[(7, 7, 6)]"},{"coefficient":-1.0,"variable":"deficit[7]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c36","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_qg[24]"},{"coefficient":1.0,"variable":"0_q[(8, 7, 8)]"},{"coefficient":1.0,"variable":"0_q[(9, 7, 10)]"},{"coefficient":1.0,"variable":"0_q[(7, 7, 6)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c37","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(28, 25, 26)]"},{"coefficient":1.0,"variable":"0_p[(27, 25, 24)]"},{"coefficient":-1.0,"variable":"deficit[25]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.0004825663866386638}},{"name":"c38","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(28, 25, 26)]"},{"coefficient":1.0,"variable":"0_q[(27, 25, 24)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-5.790796639663966e-5}},{"name":"c39","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(4, 4, 5)]"},{"coefficient":1.0,"variable":"0_p[(3, 4, 3)]"},{"coefficient":-1.0,"variable":"deficit[4]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.02040724338005229}},{"name":"c40","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(4, 4, 5)]"},{"coefficient":1.0,"variable":"0_q[(3, 4, 3)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.002448869205606275}},{"name":"c41","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(16, 13, 14)]"},{"coefficient":1.0,"variable":"0_p[(15, 13, 12)]"},{"coefficient":-1.0,"variable":"deficit[13]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.0004825663866386638}},{"name":"c42","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(16, 13, 14)]"},{"coefficient":1.0,"variable":"0_q[(15, 13, 12)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-5.790796639663966e-5}},{"name":"c43","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(17, 15, 14)]"},{"coefficient":-1.0,"variable":"deficit[15]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.10015864047547611}},{"name":"c44","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(17, 15, 14)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.012019036857057132}},{"name":"c45","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(1, 2, 1)]"},{"coefficient":1.0,"variable":"0_p[(2, 2, 3)]"},{"coefficient":-1.0,"variable":"deficit[2]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c46","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(1, 2, 1)]"},{"coefficient":1.0,"variable":"0_q[(2, 2, 3)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c47","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[27]"},{"coefficient":1.0,"variable":"0_p[(29, 27, 17)]"},{"coefficient":-1.0,"variable":"deficit[27]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c48","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_qg[27]"},{"coefficient":1.0,"variable":"0_q[(29, 27, 17)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c49","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(24, 21, 22)]"},{"coefficient":1.0,"variable":"0_p[(23, 21, 20)]"},{"coefficient":-1.0,"variable":"deficit[21]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c50","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(24, 21, 22)]"},{"coefficient":1.0,"variable":"0_q[(23, 21, 20)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c51","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[23]"},{"coefficient":-1.0,"variable":"0_pg[22]"},{"coefficient":1.0,"variable":"0_p[(28, 26, 25)]"},{"coefficient":-1.0,"variable":"deficit[26]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.1700922829782978}},{"name":"c52","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_qg[23]"},{"coefficient":-1.0,"variable":"0_qg[22]"},{"coefficient":1.0,"variable":"0_q[(28, 26, 25)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.020411073957395734}},{"name":"c53","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_pg[26]"},{"coefficient":1.0,"variable":"0_p[(11, 10, 9)]"},{"coefficient":1.0,"variable":"0_p[(9, 10, 7)]"},{"coefficient":-1.0,"variable":"deficit[10]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.5563327884359863}},{"name":"c54","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"0_qg[26]"},{"coefficient":1.0,"variable":"0_q[(11, 10, 9)]"},{"coefficient":1.0,"variable":"0_q[(9, 10, 7)]"}],"constant":0.0},"set":{"type":"EqualTo","value":-0.06675993461231836}},{"name":"c55","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_p[(21, 18, 16)]"},{"coefficient":1.0,"variable":"0_p[(14, 18, 11)]"},{"coefficient":-1.0,"variable":"deficit[18]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c56","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"0_q[(21, 18, 16)]"},{"coefficient":1.0,"variable":"0_q[(14, 18, 11)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c57","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.4213950047523992,"variable":"0_w[5]"},{"coefficient":0.4213950047523992,"variable":"0_wr[(5, 6)]"},{"coefficient":-12.485777918589607,"variable":"0_wi[(5, 6)]"},{"coefficient":1.0,"variable":"0_p[(5, 5, 6)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c58","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-12.485777918589607,"variable":"0_w[5]"},{"coefficient":12.485777918589607,"variable":"0_wr[(5, 6)]"},{"coefficient":0.4213950047523992,"variable":"0_wi[(5, 6)]"},{"coefficient":1.0,"variable":"0_q[(5, 5, 6)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c59","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.4213950047523992,"variable":"0_w[6]"},{"coefficient":0.4213950047523992,"variable":"0_wr[(5, 6)]"},{"coefficient":12.485777918589607,"variable":"0_wi[(5, 6)]"},{"coefficient":1.0,"variable":"0_p[(5, 6, 5)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c60","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-12.485777918589607,"variable":"0_w[6]"},{"coefficient":12.485777918589607,"variable":"0_wr[(5, 6)]"},{"coefficient":-0.4213950047523992,"variable":"0_wi[(5, 6)]"},{"coefficient":1.0,"variable":"0_q[(5, 6, 5)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c61","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-2.46024690223052,"variable":"0_w[13]"},{"coefficient":2.46024690223052,"variable":"0_wr[(13, 14)]"},{"coefficient":-6.795713842466891,"variable":"0_wi[(13, 14)]"},{"coefficient":1.0,"variable":"0_p[(16, 13, 14)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c62","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-6.787563842466891,"variable":"0_w[13]"},{"coefficient":6.795713842466891,"variable":"0_wr[(13, 14)]"},{"coefficient":2.46024690223052,"variable":"0_wi[(13, 14)]"},{"coefficient":1.0,"variable":"0_q[(16, 13, 14)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c63","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-2.46024690223052,"variable":"0_w[14]"},{"coefficient":2.46024690223052,"variable":"0_wr[(13, 14)]"},{"coefficient":6.795713842466891,"variable":"0_wi[(13, 14)]"},{"coefficient":1.0,"variable":"0_p[(16, 14, 13)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c64","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-6.787563842466891,"variable":"0_w[14]"},{"coefficient":6.795713842466891,"variable":"0_wr[(13, 14)]"},{"coefficient":-2.46024690223052,"variable":"0_wi[(13, 14)]"},{"coefficient":1.0,"variable":"0_q[(16, 14, 13)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c65","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.7456627284627748,"variable":"0_w[16]"},{"coefficient":0.7456627284627748,"variable":"0_wr[(16, 17)]"},{"coefficient":-10.149298248521102,"variable":"0_wi[(16, 17)]"},{"coefficient":1.0,"variable":"0_p[(20, 16, 17)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c66","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-10.149298248521102,"variable":"0_w[16]"},{"coefficient":10.149298248521102,"variable":"0_wr[(16, 17)]"},{"coefficient":0.7456627284627748,"variable":"0_wi[(16, 17)]"},{"coefficient":1.0,"variable":"0_q[(20, 16, 17)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c67","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.7456627284627748,"variable":"0_w[17]"},{"coefficient":0.7456627284627748,"variable":"0_wr[(16, 17)]"},{"coefficient":10.149298248521102,"variable":"0_wi[(16, 17)]"},{"coefficient":1.0,"variable":"0_p[(20, 17, 16)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c68","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-10.149298248521102,"variable":"0_w[17]"},{"coefficient":10.149298248521102,"variable":"0_wr[(16, 17)]"},{"coefficient":-0.7456627284627748,"variable":"0_wi[(16, 17)]"},{"coefficient":1.0,"variable":"0_q[(20, 17, 16)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c69","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-2.3473152225768015,"variable":"0_w[9]"},{"coefficient":2.3473152225768015,"variable":"0_wr[(9, 12)]"},{"coefficient":-6.481250938450924,"variable":"0_wi[(9, 12)]"},{"coefficient":1.0,"variable":"0_p[(12, 9, 12)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c70","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-6.472700938450925,"variable":"0_w[9]"},{"coefficient":6.481250938450924,"variable":"0_wr[(9, 12)]"},{"coefficient":2.3473152225768015,"variable":"0_wi[(9, 12)]"},{"coefficient":1.0,"variable":"0_q[(12, 9, 12)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c71","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-2.3473152225768015,"variable":"0_w[12]"},{"coefficient":2.3473152225768015,"variable":"0_wr[(9, 12)]"},{"coefficient":6.481250938450924,"variable":"0_wi[(9, 12)]"},{"coefficient":1.0,"variable":"0_p[(12, 12, 9)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c72","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-6.472700938450925,"variable":"0_w[12]"},{"coefficient":6.481250938450924,"variable":"0_wr[(9, 12)]"},{"coefficient":-2.3473152225768015,"variable":"0_wi[(9, 12)]"},{"coefficient":1.0,"variable":"0_q[(12, 12, 9)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c73","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.13631367642289954,"variable":"0_w[21]"},{"coefficient":0.13631367642289954,"variable":"0_wr[(21, 22)]"},{"coefficient":-4.2328983731321435,"variable":"0_wi[(21, 22)]"},{"coefficient":1.0,"variable":"0_p[(24, 21, 22)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c74","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-4.2328983731321435,"variable":"0_w[21]"},{"coefficient":4.2328983731321435,"variable":"0_wr[(21, 22)]"},{"coefficient":0.13631367642289954,"variable":"0_wi[(21, 22)]"},{"coefficient":1.0,"variable":"0_q[(24, 21, 22)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c75","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.13631367642289954,"variable":"0_w[22]"},{"coefficient":0.13631367642289954,"variable":"0_wr[(21, 22)]"},{"coefficient":4.2328983731321435,"variable":"0_wi[(21, 22)]"},{"coefficient":1.0,"variable":"0_p[(24, 22, 21)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c76","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-4.2328983731321435,"variable":"0_w[22]"},{"coefficient":4.2328983731321435,"variable":"0_wr[(21, 22)]"},{"coefficient":-0.13631367642289954,"variable":"0_wi[(21, 22)]"},{"coefficient":1.0,"variable":"0_q[(24, 22, 21)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c77","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0916977112407253,"variable":"0_w[25]"},{"coefficient":1.0916977112407253,"variable":"0_wr[(25, 26)]"},{"coefficient":-2.091029561081878,"variable":"0_wi[(25, 26)]"},{"coefficient":1.0,"variable":"0_p[(28, 25, 26)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c78","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-2.088179561081878,"variable":"0_w[25]"},{"coefficient":2.091029561081878,"variable":"0_wr[(25, 26)]"},{"coefficient":1.0916977112407253,"variable":"0_wi[(25, 26)]"},{"coefficient":1.0,"variable":"0_q[(28, 25, 26)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c79","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0916977112407253,"variable":"0_w[26]"},{"coefficient":1.0916977112407253,"variable":"0_wr[(25, 26)]"},{"coefficient":2.091029561081878,"variable":"0_wi[(25, 26)]"},{"coefficient":1.0,"variable":"0_p[(28, 26, 25)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c80","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-2.088179561081878,"variable":"0_w[26]"},{"coefficient":2.091029561081878,"variable":"0_wr[(25, 26)]"},{"coefficient":-1.0916977112407253,"variable":"0_wi[(25, 26)]"},{"coefficient":1.0,"variable":"0_q[(28, 26, 25)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c81","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-15.980730481506358,"variable":"0_w[7]"},{"coefficient":15.980730481506358,"variable":"0_wr[(7, 8)]"},{"coefficient":-45.39453875906154,"variable":"0_wi[(7, 8)]"},{"coefficient":1.0,"variable":"0_p[(8, 7, 8)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c82","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-45.39333875906154,"variable":"0_w[7]"},{"coefficient":45.39453875906154,"variable":"0_wr[(7, 8)]"},{"coefficient":15.980730481506358,"variable":"0_wi[(7, 8)]"},{"coefficient":1.0,"variable":"0_q[(8, 7, 8)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c83","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-15.980730481506358,"variable":"0_w[8]"},{"coefficient":15.980730481506358,"variable":"0_wr[(7, 8)]"},{"coefficient":45.39453875906154,"variable":"0_wi[(7, 8)]"},{"coefficient":1.0,"variable":"0_p[(8, 8, 7)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c84","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-45.39333875906154,"variable":"0_w[8]"},{"coefficient":45.39453875906154,"variable":"0_wr[(7, 8)]"},{"coefficient":-15.980730481506358,"variable":"0_wi[(7, 8)]"},{"coefficient":1.0,"variable":"0_q[(8, 8, 7)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c85","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.4325735387749903,"variable":"0_w[14]"},{"coefficient":1.4325735387749903,"variable":"0_wr[(14, 15)]"},{"coefficient":-19.8968547052082,"variable":"0_wi[(14, 15)]"},{"coefficient":1.0,"variable":"0_p[(17, 14, 15)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c86","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-19.8968547052082,"variable":"0_w[14]"},{"coefficient":19.8968547052082,"variable":"0_wr[(14, 15)]"},{"coefficient":1.4325735387749903,"variable":"0_wi[(14, 15)]"},{"coefficient":1.0,"variable":"0_q[(17, 14, 15)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c87","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.4325735387749903,"variable":"0_w[15]"},{"coefficient":1.4325735387749903,"variable":"0_wr[(14, 15)]"},{"coefficient":19.8968547052082,"variable":"0_wi[(14, 15)]"},{"coefficient":1.0,"variable":"0_p[(17, 15, 14)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c88","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-19.8968547052082,"variable":"0_w[15]"},{"coefficient":19.8968547052082,"variable":"0_wr[(14, 15)]"},{"coefficient":-1.4325735387749903,"variable":"0_wi[(14, 15)]"},{"coefficient":1.0,"variable":"0_q[(17, 15, 14)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c89","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8777625235737184,"variable":"0_w[19]"},{"coefficient":0.8777625235737184,"variable":"0_wr[(19, 28)]"},{"coefficient":-9.121944633618186,"variable":"0_wi[(19, 28)]"},{"coefficient":1.0,"variable":"0_p[(30, 19, 28)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c90","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-9.097144633618186,"variable":"0_w[19]"},{"coefficient":9.121944633618186,"variable":"0_wr[(19, 28)]"},{"coefficient":0.8777625235737184,"variable":"0_wi[(19, 28)]"},{"coefficient":1.0,"variable":"0_q[(30, 19, 28)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c91","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8777625235737184,"variable":"0_w[28]"},{"coefficient":0.8777625235737184,"variable":"0_wr[(19, 28)]"},{"coefficient":9.121944633618186,"variable":"0_wi[(19, 28)]"},{"coefficient":1.0,"variable":"0_p[(30, 28, 19)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c92","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-9.097144633618186,"variable":"0_w[28]"},{"coefficient":9.121944633618186,"variable":"0_wr[(19, 28)]"},{"coefficient":-0.8777625235737184,"variable":"0_wi[(19, 28)]"},{"coefficient":1.0,"variable":"0_q[(30, 28, 19)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c93","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.28958087993976717,"variable":"0_w[2]"},{"coefficient":0.28958087993976717,"variable":"0_wr[(2, 1)]"},{"coefficient":-9.363115118052471,"variable":"0_wi[(2, 1)]"},{"coefficient":1.0,"variable":"0_p[(1, 2, 1)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c94","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-9.363115118052471,"variable":"0_w[2]"},{"coefficient":9.363115118052471,"variable":"0_wr[(2, 1)]"},{"coefficient":0.28958087993976717,"variable":"0_wi[(2, 1)]"},{"coefficient":1.0,"variable":"0_q[(1, 2, 1)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c95","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.28958087993976717,"variable":"0_w[1]"},{"coefficient":0.28958087993976717,"variable":"0_wr[(2, 1)]"},{"coefficient":9.363115118052471,"variable":"0_wi[(2, 1)]"},{"coefficient":1.0,"variable":"0_p[(1, 1, 2)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c96","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-9.363115118052471,"variable":"0_w[1]"},{"coefficient":9.363115118052471,"variable":"0_wr[(2, 1)]"},{"coefficient":-0.28958087993976717,"variable":"0_wi[(2, 1)]"},{"coefficient":1.0,"variable":"0_q[(1, 1, 2)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c97","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.128676282013955,"variable":"0_w[20]"},{"coefficient":1.128676282013955,"variable":"0_wr[(20, 21)]"},{"coefficient":-3.33399327650884,"variable":"0_wi[(20, 21)]"},{"coefficient":1.0,"variable":"0_p[(23, 20, 21)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c98","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-3.3189932765088397,"variable":"0_w[20]"},{"coefficient":3.33399327650884,"variable":"0_wr[(20, 21)]"},{"coefficient":1.128676282013955,"variable":"0_wi[(20, 21)]"},{"coefficient":1.0,"variable":"0_q[(23, 20, 21)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c99","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.128676282013955,"variable":"0_w[21]"},{"coefficient":1.128676282013955,"variable":"0_wr[(20, 21)]"},{"coefficient":3.33399327650884,"variable":"0_wi[(20, 21)]"},{"coefficient":1.0,"variable":"0_p[(23, 21, 20)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c100","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-3.3189932765088397,"variable":"0_w[21]"},{"coefficient":3.33399327650884,"variable":"0_wr[(20, 21)]"},{"coefficient":-1.128676282013955,"variable":"0_wi[(20, 21)]"},{"coefficient":1.0,"variable":"0_q[(23, 21, 20)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c101","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8287243608560181,"variable":"0_w[16]"},{"coefficient":0.8287243608560181,"variable":"0_wr[(16, 19)]"},{"coefficient":-2.8140484527509644,"variable":"0_wi[(16, 19)]"},{"coefficient":1.0,"variable":"0_p[(22, 16, 19)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c102","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-2.7777484527509646,"variable":"0_w[16]"},{"coefficient":2.8140484527509644,"variable":"0_wr[(16, 19)]"},{"coefficient":0.8287243608560181,"variable":"0_wi[(16, 19)]"},{"coefficient":1.0,"variable":"0_q[(22, 16, 19)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c103","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8287243608560181,"variable":"0_w[19]"},{"coefficient":0.8287243608560181,"variable":"0_wr[(16, 19)]"},{"coefficient":2.8140484527509644,"variable":"0_wi[(16, 19)]"},{"coefficient":1.0,"variable":"0_p[(22, 19, 16)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c104","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-2.7777484527509646,"variable":"0_w[19]"},{"coefficient":2.8140484527509644,"variable":"0_wr[(16, 19)]"},{"coefficient":-0.8287243608560181,"variable":"0_wi[(16, 19)]"},{"coefficient":1.0,"variable":"0_q[(22, 19, 16)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c105","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.2416585439004273,"variable":"0_w[14]"},{"coefficient":1.2416585439004273,"variable":"0_wr[(14, 16)]"},{"coefficient":-3.667991302391842,"variable":"0_wi[(14, 16)]"},{"coefficient":1.0,"variable":"0_p[(19, 14, 16)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c106","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-3.654341302391842,"variable":"0_w[14]"},{"coefficient":3.667991302391842,"variable":"0_wr[(14, 16)]"},{"coefficient":1.2416585439004273,"variable":"0_wi[(14, 16)]"},{"coefficient":1.0,"variable":"0_q[(19, 14, 16)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c107","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.2416585439004273,"variable":"0_w[16]"},{"coefficient":1.2416585439004273,"variable":"0_wr[(14, 16)]"},{"coefficient":3.667991302391842,"variable":"0_wi[(14, 16)]"},{"coefficient":1.0,"variable":"0_p[(19, 16, 14)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c108","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-3.654341302391842,"variable":"0_w[16]"},{"coefficient":3.667991302391842,"variable":"0_wr[(14, 16)]"},{"coefficient":-1.2416585439004273,"variable":"0_wi[(14, 16)]"},{"coefficient":1.0,"variable":"0_q[(19, 16, 14)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c109","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-3.027806843733998,"variable":"0_w[5]"},{"coefficient":3.027806843733998,"variable":"0_wr[(5, 11)]"},{"coefficient":-20.88296190751831,"variable":"0_wi[(5, 11)]"},{"coefficient":1.0,"variable":"0_p[(6, 5, 11)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c110","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-20.83991190751831,"variable":"0_w[5]"},{"coefficient":20.88296190751831,"variable":"0_wr[(5, 11)]"},{"coefficient":3.027806843733998,"variable":"0_wi[(5, 11)]"},{"coefficient":1.0,"variable":"0_q[(6, 5, 11)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c111","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-3.027806843733998,"variable":"0_w[11]"},{"coefficient":3.027806843733998,"variable":"0_wr[(5, 11)]"},{"coefficient":20.88296190751831,"variable":"0_wi[(5, 11)]"},{"coefficient":1.0,"variable":"0_p[(6, 11, 5)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c112","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-20.83991190751831,"variable":"0_w[11]"},{"coefficient":20.88296190751831,"variable":"0_wr[(5, 11)]"},{"coefficient":-3.027806843733998,"variable":"0_wi[(5, 11)]"},{"coefficient":1.0,"variable":"0_q[(6, 11, 5)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c113","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-17.788682717374634,"variable":"0_w[9]"},{"coefficient":17.788682717374634,"variable":"0_wr[(9, 10)]"},{"coefficient":-52.44594387363901,"variable":"0_wi[(9, 10)]"},{"coefficient":1.0,"variable":"0_p[(11, 9, 10)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c114","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-52.44499387363901,"variable":"0_w[9]"},{"coefficient":52.44594387363901,"variable":"0_wr[(9, 10)]"},{"coefficient":17.788682717374634,"variable":"0_wi[(9, 10)]"},{"coefficient":1.0,"variable":"0_q[(11, 9, 10)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c115","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-17.788682717374634,"variable":"0_w[10]"},{"coefficient":17.788682717374634,"variable":"0_wr[(9, 10)]"},{"coefficient":52.44594387363901,"variable":"0_wi[(9, 10)]"},{"coefficient":1.0,"variable":"0_p[(11, 10, 9)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c116","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-52.44499387363901,"variable":"0_w[10]"},{"coefficient":52.44594387363901,"variable":"0_wr[(9, 10)]"},{"coefficient":-17.788682717374634,"variable":"0_wi[(9, 10)]"},{"coefficient":1.0,"variable":"0_q[(11, 10, 9)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c117","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.9656776626482336,"variable":"0_w[19]"},{"coefficient":0.9656776626482336,"variable":"0_wr[(19, 28)]"},{"coefficient":-5.498037005409949,"variable":"0_wi[(19, 28)]"},{"coefficient":1.0,"variable":"0_p[(31, 19, 28)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c118","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-5.487437005409949,"variable":"0_w[19]"},{"coefficient":5.498037005409949,"variable":"0_wr[(19, 28)]"},{"coefficient":0.9656776626482336,"variable":"0_wi[(19, 28)]"},{"coefficient":1.0,"variable":"0_q[(31, 19, 28)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c119","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.9656776626482336,"variable":"0_w[28]"},{"coefficient":0.9656776626482336,"variable":"0_wr[(19, 28)]"},{"coefficient":5.498037005409949,"variable":"0_wi[(19, 28)]"},{"coefficient":1.0,"variable":"0_p[(31, 28, 19)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c120","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-5.487437005409949,"variable":"0_w[28]"},{"coefficient":5.498037005409949,"variable":"0_wr[(19, 28)]"},{"coefficient":-0.9656776626482336,"variable":"0_wi[(19, 28)]"},{"coefficient":1.0,"variable":"0_q[(31, 28, 19)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c121","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-2.3418494649701906,"variable":"0_w[7]"},{"coefficient":2.3418494649701906,"variable":"0_wr[(7, 10)]"},{"coefficient":-6.467289330533839,"variable":"0_wi[(7, 10)]"},{"coefficient":1.0,"variable":"0_p[(9, 7, 10)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c122","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-6.458739330533839,"variable":"0_w[7]"},{"coefficient":6.467289330533839,"variable":"0_wr[(7, 10)]"},{"coefficient":2.3418494649701906,"variable":"0_wi[(7, 10)]"},{"coefficient":1.0,"variable":"0_q[(9, 7, 10)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c123","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-2.3418494649701906,"variable":"0_w[10]"},{"coefficient":2.3418494649701906,"variable":"0_wr[(7, 10)]"},{"coefficient":6.467289330533839,"variable":"0_wi[(7, 10)]"},{"coefficient":1.0,"variable":"0_p[(9, 10, 7)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c124","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-6.458739330533839,"variable":"0_w[10]"},{"coefficient":6.467289330533839,"variable":"0_wr[(7, 10)]"},{"coefficient":-2.3418494649701906,"variable":"0_wi[(7, 10)]"},{"coefficient":1.0,"variable":"0_q[(9, 10, 7)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c125","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.2592269273704175,"variable":"0_w[11]"},{"coefficient":1.2592269273704175,"variable":"0_wr[(11, 18)]"},{"coefficient":-8.698708713000553,"variable":"0_wi[(11, 18)]"},{"coefficient":1.0,"variable":"0_p[(14, 11, 18)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c126","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-8.595708713000553,"variable":"0_w[11]"},{"coefficient":8.698708713000553,"variable":"0_wr[(11, 18)]"},{"coefficient":1.2592269273704175,"variable":"0_wi[(11, 18)]"},{"coefficient":1.0,"variable":"0_q[(14, 11, 18)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c127","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.2592269273704175,"variable":"0_w[18]"},{"coefficient":1.2592269273704175,"variable":"0_wr[(11, 18)]"},{"coefficient":8.698708713000553,"variable":"0_wi[(11, 18)]"},{"coefficient":1.0,"variable":"0_p[(14, 18, 11)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c128","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-8.595708713000553,"variable":"0_w[18]"},{"coefficient":8.698708713000553,"variable":"0_wr[(11, 18)]"},{"coefficient":-1.2592269273704175,"variable":"0_wi[(11, 18)]"},{"coefficient":1.0,"variable":"0_q[(14, 18, 11)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c129","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-2.5442206253457624,"variable":"0_w[3]"},{"coefficient":2.5442206253457624,"variable":"0_wr[(3, 4)]"},{"coefficient":-17.010777436904807,"variable":"0_wi[(3, 4)]"},{"coefficient":1.0,"variable":"0_p[(3, 3, 4)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c130","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-16.954277436904807,"variable":"0_w[3]"},{"coefficient":17.010777436904807,"variable":"0_wr[(3, 4)]"},{"coefficient":2.5442206253457624,"variable":"0_wi[(3, 4)]"},{"coefficient":1.0,"variable":"0_q[(3, 3, 4)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c131","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-2.5442206253457624,"variable":"0_w[4]"},{"coefficient":2.5442206253457624,"variable":"0_wr[(3, 4)]"},{"coefficient":17.010777436904807,"variable":"0_wi[(3, 4)]"},{"coefficient":1.0,"variable":"0_p[(3, 4, 3)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c132","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-16.954277436904807,"variable":"0_w[4]"},{"coefficient":17.010777436904807,"variable":"0_wr[(3, 4)]"},{"coefficient":-2.5442206253457624,"variable":"0_wi[(3, 4)]"},{"coefficient":1.0,"variable":"0_q[(3, 4, 3)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c133","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.5382017465334347,"variable":"0_w[17]"},{"coefficient":0.5382017465334347,"variable":"0_wr[(17, 27)]"},{"coefficient":-1.6861921183958626,"variable":"0_wi[(17, 27)]"},{"coefficient":1.0,"variable":"0_p[(29, 17, 27)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c134","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.6861921183958626,"variable":"0_w[17]"},{"coefficient":1.6861921183958626,"variable":"0_wr[(17, 27)]"},{"coefficient":0.5382017465334347,"variable":"0_wi[(17, 27)]"},{"coefficient":1.0,"variable":"0_q[(29, 17, 27)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c135","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.5382017465334347,"variable":"0_w[27]"},{"coefficient":0.5382017465334347,"variable":"0_wr[(17, 27)]"},{"coefficient":1.6861921183958626,"variable":"0_wi[(17, 27)]"},{"coefficient":1.0,"variable":"0_p[(29, 27, 17)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c136","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.6861921183958626,"variable":"0_w[27]"},{"coefficient":1.6861921183958626,"variable":"0_wr[(17, 27)]"},{"coefficient":-0.5382017465334347,"variable":"0_wi[(17, 27)]"},{"coefficient":1.0,"variable":"0_q[(29, 27, 17)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c137","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-10.614654857863137,"variable":"0_w[6]"},{"coefficient":10.614654857863137,"variable":"0_wr[(6, 7)]"},{"coefficient":-31.512256609281188,"variable":"0_wi[(6, 7)]"},{"coefficient":1.0,"variable":"0_p[(7, 6, 7)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c138","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-31.510656609281188,"variable":"0_w[6]"},{"coefficient":31.512256609281188,"variable":"0_wr[(6, 7)]"},{"coefficient":10.614654857863137,"variable":"0_wi[(6, 7)]"},{"coefficient":1.0,"variable":"0_q[(7, 6, 7)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c139","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-10.614654857863137,"variable":"0_w[7]"},{"coefficient":10.614654857863137,"variable":"0_wr[(6, 7)]"},{"coefficient":31.512256609281188,"variable":"0_wi[(6, 7)]"},{"coefficient":1.0,"variable":"0_p[(7, 7, 6)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c140","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-31.510656609281188,"variable":"0_w[7]"},{"coefficient":31.512256609281188,"variable":"0_wr[(6, 7)]"},{"coefficient":-10.614654857863137,"variable":"0_wi[(6, 7)]"},{"coefficient":1.0,"variable":"0_q[(7, 7, 6)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c141","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-4.66785040912336,"variable":"0_w[22]"},{"coefficient":4.66785040912336,"variable":"0_wr[(22, 23)]"},{"coefficient":-8.939086077602251,"variable":"0_wi[(22, 23)]"},{"coefficient":1.0,"variable":"0_p[(25, 22, 23)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c142","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-8.938436077602251,"variable":"0_w[22]"},{"coefficient":8.939086077602251,"variable":"0_wr[(22, 23)]"},{"coefficient":4.66785040912336,"variable":"0_wi[(22, 23)]"},{"coefficient":1.0,"variable":"0_q[(25, 22, 23)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c143","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-4.66785040912336,"variable":"0_w[23]"},{"coefficient":4.66785040912336,"variable":"0_wr[(22, 23)]"},{"coefficient":8.939086077602251,"variable":"0_wi[(22, 23)]"},{"coefficient":1.0,"variable":"0_p[(25, 23, 22)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c144","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-8.938436077602251,"variable":"0_w[23]"},{"coefficient":8.939086077602251,"variable":"0_wr[(22, 23)]"},{"coefficient":-4.66785040912336,"variable":"0_wi[(22, 23)]"},{"coefficient":1.0,"variable":"0_q[(25, 23, 22)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c145","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-2.434853977156145,"variable":"0_w[4]"},{"coefficient":2.434853977156145,"variable":"0_wr[(4, 5)]"},{"coefficient":-16.36003009370084,"variable":"0_wi[(4, 5)]"},{"coefficient":1.0,"variable":"0_p[(4, 4, 5)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c146","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-16.30153009370084,"variable":"0_w[4]"},{"coefficient":16.36003009370084,"variable":"0_wr[(4, 5)]"},{"coefficient":2.434853977156145,"variable":"0_wi[(4, 5)]"},{"coefficient":1.0,"variable":"0_q[(4, 4, 5)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c147","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-2.434853977156145,"variable":"0_w[5]"},{"coefficient":2.434853977156145,"variable":"0_wr[(4, 5)]"},{"coefficient":16.36003009370084,"variable":"0_wi[(4, 5)]"},{"coefficient":1.0,"variable":"0_p[(4, 5, 4)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c148","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-16.30153009370084,"variable":"0_w[5]"},{"coefficient":16.36003009370084,"variable":"0_wr[(4, 5)]"},{"coefficient":-2.434853977156145,"variable":"0_wi[(4, 5)]"},{"coefficient":1.0,"variable":"0_q[(4, 5, 4)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c149","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.64335500582701,"variable":"0_w[9]"},{"coefficient":0.64335500582701,"variable":"0_wr[(9, 16)]"},{"coefficient":-1.8998888915041532,"variable":"0_wi[(9, 16)]"},{"coefficient":1.0,"variable":"0_p[(13, 9, 16)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c150","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.8735888915041532,"variable":"0_w[9]"},{"coefficient":1.8998888915041532,"variable":"0_wr[(9, 16)]"},{"coefficient":0.64335500582701,"variable":"0_wi[(9, 16)]"},{"coefficient":1.0,"variable":"0_q[(13, 9, 16)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c151","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.64335500582701,"variable":"0_w[16]"},{"coefficient":0.64335500582701,"variable":"0_wr[(9, 16)]"},{"coefficient":1.8998888915041532,"variable":"0_wi[(9, 16)]"},{"coefficient":1.0,"variable":"0_p[(13, 16, 9)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c152","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.8735888915041532,"variable":"0_w[16]"},{"coefficient":1.8998888915041532,"variable":"0_wr[(9, 16)]"},{"coefficient":-0.64335500582701,"variable":"0_wi[(9, 16)]"},{"coefficient":1.0,"variable":"0_q[(13, 16, 9)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c153","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-2.5424832182137913,"variable":"0_w[12]"},{"coefficient":2.5424832182137913,"variable":"0_wr[(12, 13)]"},{"coefficient":-7.029547007720768,"variable":"0_wi[(12, 13)]"},{"coefficient":1.0,"variable":"0_p[(15, 12, 13)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c154","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-7.021647007720768,"variable":"0_w[12]"},{"coefficient":7.029547007720768,"variable":"0_wr[(12, 13)]"},{"coefficient":2.5424832182137913,"variable":"0_wi[(12, 13)]"},{"coefficient":1.0,"variable":"0_q[(15, 12, 13)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c155","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-2.5424832182137913,"variable":"0_w[13]"},{"coefficient":2.5424832182137913,"variable":"0_wr[(12, 13)]"},{"coefficient":7.029547007720768,"variable":"0_wi[(12, 13)]"},{"coefficient":1.0,"variable":"0_p[(15, 13, 12)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c156","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-7.021647007720768,"variable":"0_w[13]"},{"coefficient":7.029547007720768,"variable":"0_wr[(12, 13)]"},{"coefficient":-2.5424832182137913,"variable":"0_wi[(12, 13)]"},{"coefficient":1.0,"variable":"0_q[(15, 13, 12)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c157","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.070955528571676,"variable":"0_w[2]"},{"coefficient":1.070955528571676,"variable":"0_wr[(2, 3)]"},{"coefficient":-7.165952433825185,"variable":"0_wi[(2, 3)]"},{"coefficient":1.0,"variable":"0_p[(2, 2, 3)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c158","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-7.031952433825185,"variable":"0_w[2]"},{"coefficient":7.165952433825185,"variable":"0_wr[(2, 3)]"},{"coefficient":1.070955528571676,"variable":"0_wi[(2, 3)]"},{"coefficient":1.0,"variable":"0_q[(2, 2, 3)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c159","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.070955528571676,"variable":"0_w[3]"},{"coefficient":1.070955528571676,"variable":"0_wr[(2, 3)]"},{"coefficient":7.165952433825185,"variable":"0_wi[(2, 3)]"},{"coefficient":1.0,"variable":"0_p[(2, 3, 2)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c160","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-7.031952433825185,"variable":"0_w[3]"},{"coefficient":7.165952433825185,"variable":"0_wr[(2, 3)]"},{"coefficient":-1.070955528571676,"variable":"0_wi[(2, 3)]"},{"coefficient":1.0,"variable":"0_q[(2, 3, 2)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c161","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.4978494338705233,"variable":"0_w[24]"},{"coefficient":1.4978494338705233,"variable":"0_wr[(24, 25)]"},{"coefficient":-2.868957761798156,"variable":"0_wi[(24, 25)]"},{"coefficient":1.0,"variable":"0_p[(27, 24, 25)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c162","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-2.866907761798156,"variable":"0_w[24]"},{"coefficient":2.868957761798156,"variable":"0_wr[(24, 25)]"},{"coefficient":1.4978494338705233,"variable":"0_wi[(24, 25)]"},{"coefficient":1.0,"variable":"0_q[(27, 24, 25)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c163","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.4978494338705233,"variable":"0_w[25]"},{"coefficient":1.4978494338705233,"variable":"0_wr[(24, 25)]"},{"coefficient":2.868957761798156,"variable":"0_wi[(24, 25)]"},{"coefficient":1.0,"variable":"0_p[(27, 25, 24)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c164","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-2.866907761798156,"variable":"0_w[25]"},{"coefficient":2.868957761798156,"variable":"0_wr[(24, 25)]"},{"coefficient":-1.4978494338705233,"variable":"0_wi[(24, 25)]"},{"coefficient":1.0,"variable":"0_q[(27, 25, 24)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c165","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.26161249681590054,"variable":"0_w[18]"},{"coefficient":0.26161249681590054,"variable":"0_wr[(18, 16)]"},{"coefficient":-11.73125512037617,"variable":"0_wi[(18, 16)]"},{"coefficient":1.0,"variable":"0_p[(21, 18, 16)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c166","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-11.73125512037617,"variable":"0_w[18]"},{"coefficient":11.73125512037617,"variable":"0_wr[(18, 16)]"},{"coefficient":0.26161249681590054,"variable":"0_wi[(18, 16)]"},{"coefficient":1.0,"variable":"0_q[(21, 18, 16)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c167","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.26161249681590054,"variable":"0_w[16]"},{"coefficient":0.26161249681590054,"variable":"0_wr[(18, 16)]"},{"coefficient":11.73125512037617,"variable":"0_wi[(18, 16)]"},{"coefficient":1.0,"variable":"0_p[(21, 16, 18)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c168","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-11.73125512037617,"variable":"0_w[16]"},{"coefficient":11.73125512037617,"variable":"0_wr[(18, 16)]"},{"coefficient":-0.26161249681590054,"variable":"0_wi[(18, 16)]"},{"coefficient":1.0,"variable":"0_q[(21, 16, 18)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c169","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-2.9263284811715553,"variable":"0_w[23]"},{"coefficient":2.9263284811715553,"variable":"0_wr[(23, 24)]"},{"coefficient":-5.604798539074481,"variable":"0_wi[(23, 24)]"},{"coefficient":1.0,"variable":"0_p[(26, 23, 24)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c170","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-5.603748539074481,"variable":"0_w[23]"},{"coefficient":5.604798539074481,"variable":"0_wr[(23, 24)]"},{"coefficient":2.9263284811715553,"variable":"0_wi[(23, 24)]"},{"coefficient":1.0,"variable":"0_q[(26, 23, 24)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c171","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-2.9263284811715553,"variable":"0_w[24]"},{"coefficient":2.9263284811715553,"variable":"0_wr[(23, 24)]"},{"coefficient":5.604798539074481,"variable":"0_wi[(23, 24)]"},{"coefficient":1.0,"variable":"0_p[(26, 24, 23)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c172","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-5.603748539074481,"variable":"0_w[24]"},{"coefficient":5.604798539074481,"variable":"0_wr[(23, 24)]"},{"coefficient":-2.9263284811715553,"variable":"0_wi[(23, 24)]"},{"coefficient":1.0,"variable":"0_q[(26, 24, 23)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c173","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-2.450918029773461,"variable":"0_w[8]"},{"coefficient":2.450918029773461,"variable":"0_wr[(8, 9)]"},{"coefficient":-6.776372942488066,"variable":"0_wi[(8, 9)]"},{"coefficient":1.0,"variable":"0_p[(10, 8, 9)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c174","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-6.768172942488065,"variable":"0_w[8]"},{"coefficient":6.776372942488066,"variable":"0_wr[(8, 9)]"},{"coefficient":2.450918029773461,"variable":"0_wi[(8, 9)]"},{"coefficient":1.0,"variable":"0_q[(10, 8, 9)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c175","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-2.450918029773461,"variable":"0_w[9]"},{"coefficient":2.450918029773461,"variable":"0_wr[(8, 9)]"},{"coefficient":6.776372942488066,"variable":"0_wi[(8, 9)]"},{"coefficient":1.0,"variable":"0_p[(10, 9, 8)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c176","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-6.768172942488065,"variable":"0_w[9]"},{"coefficient":6.776372942488066,"variable":"0_wr[(8, 9)]"},{"coefficient":-2.450918029773461,"variable":"0_wi[(8, 9)]"},{"coefficient":1.0,"variable":"0_q[(10, 9, 8)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c177","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.9733135131308841,"variable":"0_w[14]"},{"coefficient":0.9733135131308841,"variable":"0_wr[(14, 20)]"},{"coefficient":-2.875699016068521,"variable":"0_wi[(14, 20)]"},{"coefficient":1.0,"variable":"0_p[(18, 14, 20)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c178","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-2.8582990160685213,"variable":"0_w[14]"},{"coefficient":2.875699016068521,"variable":"0_wr[(14, 20)]"},{"coefficient":0.9733135131308841,"variable":"0_wi[(14, 20)]"},{"coefficient":1.0,"variable":"0_q[(18, 14, 20)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c179","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.9733135131308841,"variable":"0_w[20]"},{"coefficient":0.9733135131308841,"variable":"0_wr[(14, 20)]"},{"coefficient":2.875699016068521,"variable":"0_wi[(14, 20)]"},{"coefficient":1.0,"variable":"0_p[(18, 20, 14)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c180","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-2.8582990160685213,"variable":"0_w[20]"},{"coefficient":2.875699016068521,"variable":"0_wr[(14, 20)]"},{"coefficient":-0.9733135131308841,"variable":"0_wi[(14, 20)]"},{"coefficient":1.0,"variable":"0_q[(18, 20, 14)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[1]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[1]_in"},{"coefficient":1.0,"variable":"reservoir[1]_out"},{"coefficient":0.6048,"variable":"outflow[1]"},{"coefficient":-0.6048,"variable":"outflow[2]"},{"coefficient":1.0,"variable":"spill[1]"},{"coefficient":-0.6048,"variable":"inflow[1]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[2]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[2]_in"},{"coefficient":1.0,"variable":"reservoir[2]_out"},{"coefficient":0.6048,"variable":"outflow[2]"},{"coefficient":1.0,"variable":"spill[2]"},{"coefficient":-0.6048,"variable":"inflow[2]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[3]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[3]_in"},{"coefficient":1.0,"variable":"reservoir[3]_out"},{"coefficient":0.6048,"variable":"outflow[3]"},{"coefficient":1.0,"variable":"spill[3]"},{"coefficient":-0.6048,"variable":"inflow[3]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[4]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[4]_in"},{"coefficient":1.0,"variable":"reservoir[4]_out"},{"coefficient":0.6048,"variable":"outflow[4]"},{"coefficient":1.0,"variable":"spill[4]"},{"coefficient":-0.6048,"variable":"inflow[4]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[5]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[5]_in"},{"coefficient":1.0,"variable":"reservoir[5]_out"},{"coefficient":0.6048,"variable":"outflow[5]"},{"coefficient":1.0,"variable":"spill[5]"},{"coefficient":-0.6048,"variable":"inflow[5]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[6]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[6]_in"},{"coefficient":1.0,"variable":"reservoir[6]_out"},{"coefficient":-0.6048,"variable":"outflow[5]"},{"coefficient":0.6048,"variable":"outflow[6]"},{"coefficient":-1.0,"variable":"spill[5]"},{"coefficient":1.0,"variable":"spill[6]"},{"coefficient":-0.6048,"variable":"inflow[6]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[7]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[7]_in"},{"coefficient":1.0,"variable":"reservoir[7]_out"},{"coefficient":0.6048,"variable":"outflow[7]"},{"coefficient":1.0,"variable":"spill[7]"},{"coefficient":-0.6048,"variable":"inflow[7]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[8]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[8]_in"},{"coefficient":1.0,"variable":"reservoir[8]_out"},{"coefficient":0.6048,"variable":"outflow[8]"},{"coefficient":1.0,"variable":"spill[8]"},{"coefficient":-0.6048,"variable":"inflow[8]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[9]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[9]_in"},{"coefficient":1.0,"variable":"reservoir[9]_out"},{"coefficient":-0.6048,"variable":"outflow[8]"},{"coefficient":0.6048,"variable":"outflow[9]"},{"coefficient":-1.0,"variable":"spill[8]"},{"coefficient":1.0,"variable":"spill[9]"},{"coefficient":-0.6048,"variable":"inflow[9]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[10]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[10]_in"},{"coefficient":1.0,"variable":"reservoir[10]_out"},{"coefficient":0.6048,"variable":"outflow[10]"},{"coefficient":1.0,"variable":"spill[10]"},{"coefficient":-0.6048,"variable":"inflow[10]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"hydro_balance[11]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0,"variable":"reservoir[11]_in"},{"coefficient":1.0,"variable":"reservoir[11]_out"},{"coefficient":0.6048,"variable":"outflow[11]"},{"coefficient":1.0,"variable":"spill[11]"},{"coefficient":-0.6048,"variable":"inflow[11]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[1]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[24]"},{"coefficient":-6.9953,"variable":"outflow[1]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[2]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[25]"},{"coefficient":-5.117,"variable":"outflow[2]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[3]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[26]"},{"coefficient":-9.677,"variable":"outflow[3]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[4]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[27]"},{"coefficient":-5.06,"variable":"outflow[4]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[5]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[28]"},{"coefficient":-8.11,"variable":"outflow[5]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[6]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[29]"},{"coefficient":-6.35,"variable":"outflow[6]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[7]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[30]"},{"coefficient":-3.2,"variable":"outflow[7]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[8]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[31]"},{"coefficient":-4.81,"variable":"outflow[8]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[9]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[32]"},{"coefficient":-4.47,"variable":"outflow[9]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[10]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[33]"},{"coefficient":-1.2,"variable":"outflow[10]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"turbine_energy[11]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":100.0,"variable":"0_pg[34]"},{"coefficient":-2.5,"variable":"outflow[11]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c1_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.732060602824032,"variable":"0_wr[(5, 6)]"},{"coefficient":1.0,"variable":"0_wi[(5, 6)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c2_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0999953343996005,"variable":"0_w[5]"},{"coefficient":-1.0999953343996005,"variable":"0_w[6]"},{"coefficient":4.0,"variable":"0_wr[(5, 6)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":-0.24199897356791222}},{"name":"c3_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8999961826905822,"variable":"0_w[5]"},{"coefficient":-0.8999961826905822,"variable":"0_w[6]"},{"coefficient":4.0,"variable":"0_wr[(5, 6)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.16199931288430486}},{"name":"c4_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.732060602824032,"variable":"0_wr[(13, 14)]"},{"coefficient":1.0,"variable":"0_wi[(13, 14)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c5_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0999953343996005,"variable":"0_w[14]"},{"coefficient":-1.0999953343996005,"variable":"0_w[13]"},{"coefficient":4.0,"variable":"0_wr[(13, 14)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":-0.24199897356791222}},{"name":"c6_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8999961826905822,"variable":"0_w[14]"},{"coefficient":-0.8999961826905822,"variable":"0_w[13]"},{"coefficient":4.0,"variable":"0_wr[(13, 14)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.16199931288430486}},{"name":"c7_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.732060602824032,"variable":"0_wr[(16, 17)]"},{"coefficient":1.0,"variable":"0_wi[(16, 17)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c8_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0999953343996005,"variable":"0_w[16]"},{"coefficient":-1.0999953343996005,"variable":"0_w[17]"},{"coefficient":4.0,"variable":"0_wr[(16, 17)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":-0.24199897356791222}},{"name":"c9_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8999961826905822,"variable":"0_w[16]"},{"coefficient":-0.8999961826905822,"variable":"0_w[17]"},{"coefficient":4.0,"variable":"0_wr[(16, 17)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.16199931288430486}},{"name":"c10_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.732060602824032,"variable":"0_wr[(9, 12)]"},{"coefficient":1.0,"variable":"0_wi[(9, 12)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c11_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0999953343996005,"variable":"0_w[12]"},{"coefficient":-1.0999953343996005,"variable":"0_w[9]"},{"coefficient":4.0,"variable":"0_wr[(9, 12)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":-0.24199897356791222}},{"name":"c12_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8999961826905822,"variable":"0_w[12]"},{"coefficient":-0.8999961826905822,"variable":"0_w[9]"},{"coefficient":4.0,"variable":"0_wr[(9, 12)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.16199931288430486}},{"name":"c13_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.732060602824032,"variable":"0_wr[(21, 22)]"},{"coefficient":1.0,"variable":"0_wi[(21, 22)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c14_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0999953343996005,"variable":"0_w[22]"},{"coefficient":-1.0999953343996005,"variable":"0_w[21]"},{"coefficient":4.0,"variable":"0_wr[(21, 22)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":-0.24199897356791222}},{"name":"c15_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8999961826905822,"variable":"0_w[22]"},{"coefficient":-0.8999961826905822,"variable":"0_w[21]"},{"coefficient":4.0,"variable":"0_wr[(21, 22)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.16199931288430486}},{"name":"c16_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.732060602824032,"variable":"0_wr[(25, 26)]"},{"coefficient":1.0,"variable":"0_wi[(25, 26)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c17_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0999953343996005,"variable":"0_w[25]"},{"coefficient":-1.0999953343996005,"variable":"0_w[26]"},{"coefficient":4.0,"variable":"0_wr[(25, 26)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":-0.24199897356791222}},{"name":"c18_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8999961826905822,"variable":"0_w[25]"},{"coefficient":-0.8999961826905822,"variable":"0_w[26]"},{"coefficient":4.0,"variable":"0_wr[(25, 26)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.16199931288430486}},{"name":"c19_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.732060602824032,"variable":"0_wr[(7, 8)]"},{"coefficient":1.0,"variable":"0_wi[(7, 8)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c20_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0999953343996005,"variable":"0_w[8]"},{"coefficient":-1.0999953343996005,"variable":"0_w[7]"},{"coefficient":4.0,"variable":"0_wr[(7, 8)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":-0.24199897356791222}},{"name":"c21_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8999961826905822,"variable":"0_w[8]"},{"coefficient":-0.8999961826905822,"variable":"0_w[7]"},{"coefficient":4.0,"variable":"0_wr[(7, 8)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.16199931288430486}},{"name":"c22_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.732060602824032,"variable":"0_wr[(14, 15)]"},{"coefficient":1.0,"variable":"0_wi[(14, 15)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c23_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0999953343996005,"variable":"0_w[14]"},{"coefficient":-1.0999953343996005,"variable":"0_w[15]"},{"coefficient":4.0,"variable":"0_wr[(14, 15)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":-0.24199897356791222}},{"name":"c24_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8999961826905822,"variable":"0_w[14]"},{"coefficient":-0.8999961826905822,"variable":"0_w[15]"},{"coefficient":4.0,"variable":"0_wr[(14, 15)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.16199931288430486}},{"name":"c25_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.732060602824032,"variable":"0_wr[(19, 28)]"},{"coefficient":1.0,"variable":"0_wi[(19, 28)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c26_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0999953343996005,"variable":"0_w[28]"},{"coefficient":-1.0999953343996005,"variable":"0_w[19]"},{"coefficient":4.0,"variable":"0_wr[(19, 28)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":-0.24199897356791222}},{"name":"c27_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8999961826905822,"variable":"0_w[28]"},{"coefficient":-0.8999961826905822,"variable":"0_w[19]"},{"coefficient":4.0,"variable":"0_wr[(19, 28)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.16199931288430486}},{"name":"c28_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.732060602824032,"variable":"0_wr[(2, 1)]"},{"coefficient":1.0,"variable":"0_wi[(2, 1)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c29_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0999953343996005,"variable":"0_w[1]"},{"coefficient":-1.0999953343996005,"variable":"0_w[2]"},{"coefficient":4.0,"variable":"0_wr[(2, 1)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":-0.24199897356791222}},{"name":"c30_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8999961826905822,"variable":"0_w[1]"},{"coefficient":-0.8999961826905822,"variable":"0_w[2]"},{"coefficient":4.0,"variable":"0_wr[(2, 1)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.16199931288430486}},{"name":"c31_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.732060602824032,"variable":"0_wr[(20, 21)]"},{"coefficient":1.0,"variable":"0_wi[(20, 21)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c32_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0999953343996005,"variable":"0_w[20]"},{"coefficient":-1.0999953343996005,"variable":"0_w[21]"},{"coefficient":4.0,"variable":"0_wr[(20, 21)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":-0.24199897356791222}},{"name":"c33_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8999961826905822,"variable":"0_w[20]"},{"coefficient":-0.8999961826905822,"variable":"0_w[21]"},{"coefficient":4.0,"variable":"0_wr[(20, 21)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.16199931288430486}},{"name":"c34_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.732060602824032,"variable":"0_wr[(16, 19)]"},{"coefficient":1.0,"variable":"0_wi[(16, 19)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c35_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0999953343996005,"variable":"0_w[16]"},{"coefficient":-1.0999953343996005,"variable":"0_w[19]"},{"coefficient":4.0,"variable":"0_wr[(16, 19)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":-0.24199897356791222}},{"name":"c36_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8999961826905822,"variable":"0_w[16]"},{"coefficient":-0.8999961826905822,"variable":"0_w[19]"},{"coefficient":4.0,"variable":"0_wr[(16, 19)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.16199931288430486}},{"name":"c37_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.732060602824032,"variable":"0_wr[(14, 16)]"},{"coefficient":1.0,"variable":"0_wi[(14, 16)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c38_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0999953343996005,"variable":"0_w[16]"},{"coefficient":-1.0999953343996005,"variable":"0_w[14]"},{"coefficient":4.0,"variable":"0_wr[(14, 16)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":-0.24199897356791222}},{"name":"c39_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8999961826905822,"variable":"0_w[16]"},{"coefficient":-0.8999961826905822,"variable":"0_w[14]"},{"coefficient":4.0,"variable":"0_wr[(14, 16)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.16199931288430486}},{"name":"c40_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.732060602824032,"variable":"0_wr[(5, 11)]"},{"coefficient":1.0,"variable":"0_wi[(5, 11)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c41_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0999953343996005,"variable":"0_w[5]"},{"coefficient":-1.0999953343996005,"variable":"0_w[11]"},{"coefficient":4.0,"variable":"0_wr[(5, 11)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":-0.24199897356791222}},{"name":"c42_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8999961826905822,"variable":"0_w[5]"},{"coefficient":-0.8999961826905822,"variable":"0_w[11]"},{"coefficient":4.0,"variable":"0_wr[(5, 11)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.16199931288430486}},{"name":"c43_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.732060602824032,"variable":"0_wr[(9, 10)]"},{"coefficient":1.0,"variable":"0_wi[(9, 10)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c44_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0999953343996005,"variable":"0_w[9]"},{"coefficient":-1.0999953343996005,"variable":"0_w[10]"},{"coefficient":4.0,"variable":"0_wr[(9, 10)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":-0.24199897356791222}},{"name":"c45_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8999961826905822,"variable":"0_w[9]"},{"coefficient":-0.8999961826905822,"variable":"0_w[10]"},{"coefficient":4.0,"variable":"0_wr[(9, 10)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.16199931288430486}},{"name":"c46_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.732060602824032,"variable":"0_wr[(7, 10)]"},{"coefficient":1.0,"variable":"0_wi[(7, 10)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c47_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0999953343996005,"variable":"0_w[7]"},{"coefficient":-1.0999953343996005,"variable":"0_w[10]"},{"coefficient":4.0,"variable":"0_wr[(7, 10)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":-0.24199897356791222}},{"name":"c48_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8999961826905822,"variable":"0_w[7]"},{"coefficient":-0.8999961826905822,"variable":"0_w[10]"},{"coefficient":4.0,"variable":"0_wr[(7, 10)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.16199931288430486}},{"name":"c49_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.732060602824032,"variable":"0_wr[(11, 18)]"},{"coefficient":1.0,"variable":"0_wi[(11, 18)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c50_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0999953343996005,"variable":"0_w[11]"},{"coefficient":-1.0999953343996005,"variable":"0_w[18]"},{"coefficient":4.0,"variable":"0_wr[(11, 18)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":-0.24199897356791222}},{"name":"c51_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8999961826905822,"variable":"0_w[11]"},{"coefficient":-0.8999961826905822,"variable":"0_w[18]"},{"coefficient":4.0,"variable":"0_wr[(11, 18)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.16199931288430486}},{"name":"c52_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.732060602824032,"variable":"0_wr[(3, 4)]"},{"coefficient":1.0,"variable":"0_wi[(3, 4)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c53_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0999953343996005,"variable":"0_w[3]"},{"coefficient":-1.0999953343996005,"variable":"0_w[4]"},{"coefficient":4.0,"variable":"0_wr[(3, 4)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":-0.24199897356791222}},{"name":"c54_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8999961826905822,"variable":"0_w[3]"},{"coefficient":-0.8999961826905822,"variable":"0_w[4]"},{"coefficient":4.0,"variable":"0_wr[(3, 4)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.16199931288430486}},{"name":"c55_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.732060602824032,"variable":"0_wr[(17, 27)]"},{"coefficient":1.0,"variable":"0_wi[(17, 27)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c56_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0999953343996005,"variable":"0_w[17]"},{"coefficient":-1.0999953343996005,"variable":"0_w[27]"},{"coefficient":4.0,"variable":"0_wr[(17, 27)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":-0.24199897356791222}},{"name":"c57_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8999961826905822,"variable":"0_w[17]"},{"coefficient":-0.8999961826905822,"variable":"0_w[27]"},{"coefficient":4.0,"variable":"0_wr[(17, 27)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.16199931288430486}},{"name":"c58_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.732060602824032,"variable":"0_wr[(6, 7)]"},{"coefficient":1.0,"variable":"0_wi[(6, 7)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c59_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0999953343996005,"variable":"0_w[6]"},{"coefficient":-1.0999953343996005,"variable":"0_w[7]"},{"coefficient":4.0,"variable":"0_wr[(6, 7)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":-0.24199897356791222}},{"name":"c60_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8999961826905822,"variable":"0_w[6]"},{"coefficient":-0.8999961826905822,"variable":"0_w[7]"},{"coefficient":4.0,"variable":"0_wr[(6, 7)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.16199931288430486}},{"name":"c61_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.732060602824032,"variable":"0_wr[(22, 23)]"},{"coefficient":1.0,"variable":"0_wi[(22, 23)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c62_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0999953343996005,"variable":"0_w[23]"},{"coefficient":-1.0999953343996005,"variable":"0_w[22]"},{"coefficient":4.0,"variable":"0_wr[(22, 23)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":-0.24199897356791222}},{"name":"c63_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8999961826905822,"variable":"0_w[23]"},{"coefficient":-0.8999961826905822,"variable":"0_w[22]"},{"coefficient":4.0,"variable":"0_wr[(22, 23)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.16199931288430486}},{"name":"c64_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.732060602824032,"variable":"0_wr[(4, 5)]"},{"coefficient":1.0,"variable":"0_wi[(4, 5)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c65_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0999953343996005,"variable":"0_w[5]"},{"coefficient":-1.0999953343996005,"variable":"0_w[4]"},{"coefficient":4.0,"variable":"0_wr[(4, 5)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":-0.24199897356791222}},{"name":"c66_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8999961826905822,"variable":"0_w[5]"},{"coefficient":-0.8999961826905822,"variable":"0_w[4]"},{"coefficient":4.0,"variable":"0_wr[(4, 5)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.16199931288430486}},{"name":"c67_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.732060602824032,"variable":"0_wr[(9, 16)]"},{"coefficient":1.0,"variable":"0_wi[(9, 16)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c68_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0999953343996005,"variable":"0_w[16]"},{"coefficient":-1.0999953343996005,"variable":"0_w[9]"},{"coefficient":4.0,"variable":"0_wr[(9, 16)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":-0.24199897356791222}},{"name":"c69_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8999961826905822,"variable":"0_w[16]"},{"coefficient":-0.8999961826905822,"variable":"0_w[9]"},{"coefficient":4.0,"variable":"0_wr[(9, 16)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.16199931288430486}},{"name":"c70_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.732060602824032,"variable":"0_wr[(12, 13)]"},{"coefficient":1.0,"variable":"0_wi[(12, 13)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c71_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0999953343996005,"variable":"0_w[12]"},{"coefficient":-1.0999953343996005,"variable":"0_w[13]"},{"coefficient":4.0,"variable":"0_wr[(12, 13)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":-0.24199897356791222}},{"name":"c72_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8999961826905822,"variable":"0_w[12]"},{"coefficient":-0.8999961826905822,"variable":"0_w[13]"},{"coefficient":4.0,"variable":"0_wr[(12, 13)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.16199931288430486}},{"name":"c73_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.732060602824032,"variable":"0_wr[(2, 3)]"},{"coefficient":1.0,"variable":"0_wi[(2, 3)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c74_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0999953343996005,"variable":"0_w[3]"},{"coefficient":-1.0999953343996005,"variable":"0_w[2]"},{"coefficient":4.0,"variable":"0_wr[(2, 3)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":-0.24199897356791222}},{"name":"c75_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8999961826905822,"variable":"0_w[3]"},{"coefficient":-0.8999961826905822,"variable":"0_w[2]"},{"coefficient":4.0,"variable":"0_wr[(2, 3)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.16199931288430486}},{"name":"c76_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.732060602824032,"variable":"0_wr[(24, 25)]"},{"coefficient":1.0,"variable":"0_wi[(24, 25)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c77_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0999953343996005,"variable":"0_w[24]"},{"coefficient":-1.0999953343996005,"variable":"0_w[25]"},{"coefficient":4.0,"variable":"0_wr[(24, 25)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":-0.24199897356791222}},{"name":"c78_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8999961826905822,"variable":"0_w[24]"},{"coefficient":-0.8999961826905822,"variable":"0_w[25]"},{"coefficient":4.0,"variable":"0_wr[(24, 25)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.16199931288430486}},{"name":"c79_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.732060602824032,"variable":"0_wr[(18, 16)]"},{"coefficient":1.0,"variable":"0_wi[(18, 16)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c80_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0999953343996005,"variable":"0_w[16]"},{"coefficient":-1.0999953343996005,"variable":"0_w[18]"},{"coefficient":4.0,"variable":"0_wr[(18, 16)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":-0.24199897356791222}},{"name":"c81_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8999961826905822,"variable":"0_w[16]"},{"coefficient":-0.8999961826905822,"variable":"0_w[18]"},{"coefficient":4.0,"variable":"0_wr[(18, 16)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.16199931288430486}},{"name":"c82_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.732060602824032,"variable":"0_wr[(23, 24)]"},{"coefficient":1.0,"variable":"0_wi[(23, 24)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c83_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0999953343996005,"variable":"0_w[24]"},{"coefficient":-1.0999953343996005,"variable":"0_w[23]"},{"coefficient":4.0,"variable":"0_wr[(23, 24)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":-0.24199897356791222}},{"name":"c84_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8999961826905822,"variable":"0_w[24]"},{"coefficient":-0.8999961826905822,"variable":"0_w[23]"},{"coefficient":4.0,"variable":"0_wr[(23, 24)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.16199931288430486}},{"name":"c85_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.732060602824032,"variable":"0_wr[(8, 9)]"},{"coefficient":1.0,"variable":"0_wi[(8, 9)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c86_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0999953343996005,"variable":"0_w[8]"},{"coefficient":-1.0999953343996005,"variable":"0_w[9]"},{"coefficient":4.0,"variable":"0_wr[(8, 9)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":-0.24199897356791222}},{"name":"c87_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8999961826905822,"variable":"0_w[8]"},{"coefficient":-0.8999961826905822,"variable":"0_w[9]"},{"coefficient":4.0,"variable":"0_wr[(8, 9)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.16199931288430486}},{"name":"c88_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.732060602824032,"variable":"0_wr[(14, 20)]"},{"coefficient":1.0,"variable":"0_wi[(14, 20)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c89_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.0999953343996005,"variable":"0_w[20]"},{"coefficient":-1.0999953343996005,"variable":"0_w[14]"},{"coefficient":4.0,"variable":"0_wr[(14, 20)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":-0.24199897356791222}},{"name":"c90_1","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-0.8999961826905822,"variable":"0_w[20]"},{"coefficient":-0.8999961826905822,"variable":"0_w[14]"},{"coefficient":4.0,"variable":"0_wr[(14, 20)]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.16199931288430486}},{"name":"min_volume_violation_bound[1]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[1]_out"},{"coefficient":1.0,"variable":"min_volume_violation[1]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_volume_violation_bound[2]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[2]_out"},{"coefficient":1.0,"variable":"min_volume_violation[2]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_volume_violation_bound[3]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[3]_out"},{"coefficient":1.0,"variable":"min_volume_violation[3]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_volume_violation_bound[4]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[4]_out"},{"coefficient":1.0,"variable":"min_volume_violation[4]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_volume_violation_bound[5]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[5]_out"},{"coefficient":1.0,"variable":"min_volume_violation[5]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_volume_violation_bound[6]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[6]_out"},{"coefficient":1.0,"variable":"min_volume_violation[6]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_volume_violation_bound[7]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[7]_out"},{"coefficient":1.0,"variable":"min_volume_violation[7]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_volume_violation_bound[8]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[8]_out"},{"coefficient":1.0,"variable":"min_volume_violation[8]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_volume_violation_bound[9]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[9]_out"},{"coefficient":1.0,"variable":"min_volume_violation[9]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_volume_violation_bound[10]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[10]_out"},{"coefficient":1.0,"variable":"min_volume_violation[10]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_volume_violation_bound[11]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"reservoir[11]_out"},{"coefficient":1.0,"variable":"min_volume_violation[11]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[1]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[1]"},{"coefficient":1.0,"variable":"min_outflow_violation[1]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[2]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[2]"},{"coefficient":1.0,"variable":"min_outflow_violation[2]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[3]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[3]"},{"coefficient":1.0,"variable":"min_outflow_violation[3]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[4]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[4]"},{"coefficient":1.0,"variable":"min_outflow_violation[4]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[5]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[5]"},{"coefficient":1.0,"variable":"min_outflow_violation[5]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[6]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[6]"},{"coefficient":1.0,"variable":"min_outflow_violation[6]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[7]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[7]"},{"coefficient":1.0,"variable":"min_outflow_violation[7]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[8]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[8]"},{"coefficient":1.0,"variable":"min_outflow_violation[8]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[9]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[9]"},{"coefficient":1.0,"variable":"min_outflow_violation[9]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[10]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[10]"},{"coefficient":1.0,"variable":"min_outflow_violation[10]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"min_outflow_violation_bound[11]","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.0,"variable":"outflow[11]"},{"coefficient":1.0,"variable":"min_outflow_violation[11]"}],"constant":0.0},"set":{"type":"GreaterThan","lower":0.0}},{"name":"c1_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.732060602824032,"variable":"0_wr[(5, 6)]"},{"coefficient":1.0,"variable":"0_wi[(5, 6)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0}},{"name":"c2_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.732060602824032,"variable":"0_wr[(13, 14)]"},{"coefficient":1.0,"variable":"0_wi[(13, 14)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0}},{"name":"c3_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.732060602824032,"variable":"0_wr[(16, 17)]"},{"coefficient":1.0,"variable":"0_wi[(16, 17)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0}},{"name":"c4_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.732060602824032,"variable":"0_wr[(9, 12)]"},{"coefficient":1.0,"variable":"0_wi[(9, 12)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0}},{"name":"c5_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.732060602824032,"variable":"0_wr[(21, 22)]"},{"coefficient":1.0,"variable":"0_wi[(21, 22)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0}},{"name":"c6_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.732060602824032,"variable":"0_wr[(25, 26)]"},{"coefficient":1.0,"variable":"0_wi[(25, 26)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0}},{"name":"c7_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.732060602824032,"variable":"0_wr[(7, 8)]"},{"coefficient":1.0,"variable":"0_wi[(7, 8)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0}},{"name":"c8_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.732060602824032,"variable":"0_wr[(14, 15)]"},{"coefficient":1.0,"variable":"0_wi[(14, 15)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0}},{"name":"c9_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.732060602824032,"variable":"0_wr[(19, 28)]"},{"coefficient":1.0,"variable":"0_wi[(19, 28)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0}},{"name":"c10_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.732060602824032,"variable":"0_wr[(2, 1)]"},{"coefficient":1.0,"variable":"0_wi[(2, 1)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0}},{"name":"c11_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.732060602824032,"variable":"0_wr[(20, 21)]"},{"coefficient":1.0,"variable":"0_wi[(20, 21)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0}},{"name":"c12_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.732060602824032,"variable":"0_wr[(16, 19)]"},{"coefficient":1.0,"variable":"0_wi[(16, 19)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0}},{"name":"c13_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.732060602824032,"variable":"0_wr[(14, 16)]"},{"coefficient":1.0,"variable":"0_wi[(14, 16)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0}},{"name":"c14_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.732060602824032,"variable":"0_wr[(5, 11)]"},{"coefficient":1.0,"variable":"0_wi[(5, 11)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0}},{"name":"c15_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.732060602824032,"variable":"0_wr[(9, 10)]"},{"coefficient":1.0,"variable":"0_wi[(9, 10)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0}},{"name":"c16_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.732060602824032,"variable":"0_wr[(7, 10)]"},{"coefficient":1.0,"variable":"0_wi[(7, 10)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0}},{"name":"c17_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.732060602824032,"variable":"0_wr[(11, 18)]"},{"coefficient":1.0,"variable":"0_wi[(11, 18)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0}},{"name":"c18_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.732060602824032,"variable":"0_wr[(3, 4)]"},{"coefficient":1.0,"variable":"0_wi[(3, 4)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0}},{"name":"c19_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.732060602824032,"variable":"0_wr[(17, 27)]"},{"coefficient":1.0,"variable":"0_wi[(17, 27)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0}},{"name":"c20_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.732060602824032,"variable":"0_wr[(6, 7)]"},{"coefficient":1.0,"variable":"0_wi[(6, 7)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0}},{"name":"c21_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.732060602824032,"variable":"0_wr[(22, 23)]"},{"coefficient":1.0,"variable":"0_wi[(22, 23)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0}},{"name":"c22_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.732060602824032,"variable":"0_wr[(4, 5)]"},{"coefficient":1.0,"variable":"0_wi[(4, 5)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0}},{"name":"c23_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.732060602824032,"variable":"0_wr[(9, 16)]"},{"coefficient":1.0,"variable":"0_wi[(9, 16)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0}},{"name":"c24_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.732060602824032,"variable":"0_wr[(12, 13)]"},{"coefficient":1.0,"variable":"0_wi[(12, 13)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0}},{"name":"c25_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.732060602824032,"variable":"0_wr[(2, 3)]"},{"coefficient":1.0,"variable":"0_wi[(2, 3)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0}},{"name":"c26_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.732060602824032,"variable":"0_wr[(24, 25)]"},{"coefficient":1.0,"variable":"0_wi[(24, 25)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0}},{"name":"c27_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.732060602824032,"variable":"0_wr[(18, 16)]"},{"coefficient":1.0,"variable":"0_wi[(18, 16)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0}},{"name":"c28_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.732060602824032,"variable":"0_wr[(23, 24)]"},{"coefficient":1.0,"variable":"0_wi[(23, 24)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0}},{"name":"c29_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.732060602824032,"variable":"0_wr[(8, 9)]"},{"coefficient":1.0,"variable":"0_wi[(8, 9)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0}},{"name":"c30_2","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.732060602824032,"variable":"0_wr[(14, 20)]"},{"coefficient":1.0,"variable":"0_wi[(14, 20)]"}],"constant":0.0},"set":{"type":"LessThan","upper":0.0}},{"name":"c1_3","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(5, 5, 6)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(5, 5, 6)]"}}],"constants":[0.7,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c2_3","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(5, 6, 5)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(5, 6, 5)]"}}],"constants":[0.7,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c3_3","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(16, 13, 14)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(16, 13, 14)]"}}],"constants":[0.74,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c4_3","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(16, 14, 13)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(16, 14, 13)]"}}],"constants":[0.74,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c5_3","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(20, 16, 17)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(20, 16, 17)]"}}],"constants":[0.25,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c6_3","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(20, 17, 16)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(20, 17, 16)]"}}],"constants":[0.25,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c7_3","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(12, 9, 12)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(12, 9, 12)]"}}],"constants":[0.74,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c8_3","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(12, 12, 9)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(12, 12, 9)]"}}],"constants":[0.74,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c9_3","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(24, 21, 22)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(24, 21, 22)]"}}],"constants":[0.25,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c10_3","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(24, 22, 21)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(24, 22, 21)]"}}],"constants":[0.25,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c11_3","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(28, 25, 26)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(28, 25, 26)]"}}],"constants":[0.13,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c12_3","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(28, 26, 25)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(28, 26, 25)]"}}],"constants":[0.13,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c13_3","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(8, 7, 8)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(8, 7, 8)]"}}],"constants":[0.74,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c14_3","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(8, 8, 7)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(8, 8, 7)]"}}],"constants":[0.74,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c15_3","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(17, 14, 15)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(17, 14, 15)]"}}],"constants":[0.5,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c16_3","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(17, 15, 14)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(17, 15, 14)]"}}],"constants":[0.5,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c17_3","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(30, 19, 28)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(30, 19, 28)]"}}],"constants":[1.0,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c18_3","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(30, 28, 19)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(30, 28, 19)]"}}],"constants":[1.0,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c19_3","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(1, 2, 1)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(1, 2, 1)]"}}],"constants":[0.7,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c20_3","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(1, 1, 2)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(1, 1, 2)]"}}],"constants":[0.7,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c21_3","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(23, 20, 21)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(23, 20, 21)]"}}],"constants":[0.47,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c22_3","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(23, 21, 20)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(23, 21, 20)]"}}],"constants":[0.47,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c23_3","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(22, 16, 19)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(22, 16, 19)]"}}],"constants":[1.06,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c24_3","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(22, 19, 16)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(22, 19, 16)]"}}],"constants":[1.06,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c25_3","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(19, 14, 16)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(19, 14, 16)]"}}],"constants":[0.74,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c26_3","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(19, 16, 14)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(19, 16, 14)]"}}],"constants":[0.74,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c27_3","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(6, 5, 11)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(6, 5, 11)]"}}],"constants":[1.3,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c28_3","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(6, 11, 5)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(6, 11, 5)]"}}],"constants":[1.3,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c29_3","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(11, 9, 10)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(11, 9, 10)]"}}],"constants":[0.74,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c30_3","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(11, 10, 9)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(11, 10, 9)]"}}],"constants":[0.74,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c31_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(31, 19, 28)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(31, 19, 28)]"}}],"constants":[1.0,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c32_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(31, 28, 19)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(31, 28, 19)]"}}],"constants":[1.0,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c33_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(9, 7, 10)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(9, 7, 10)]"}}],"constants":[0.74,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c34_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(9, 10, 7)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(9, 10, 7)]"}}],"constants":[0.74,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c35_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(14, 11, 18)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(14, 11, 18)]"}}],"constants":[1.3,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c36_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(14, 18, 11)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(14, 18, 11)]"}}],"constants":[1.3,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c37_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(3, 3, 4)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(3, 3, 4)]"}}],"constants":[1.3,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c38_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(3, 4, 3)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(3, 4, 3)]"}}],"constants":[1.3,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c39_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(29, 17, 27)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(29, 17, 27)]"}}],"constants":[2.0,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c40_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(29, 27, 17)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(29, 27, 17)]"}}],"constants":[2.0,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c41_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(7, 6, 7)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(7, 6, 7)]"}}],"constants":[0.74,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c42_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(7, 7, 6)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(7, 7, 6)]"}}],"constants":[0.74,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c43_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(25, 22, 23)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(25, 22, 23)]"}}],"constants":[0.33,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c44_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(25, 23, 22)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(25, 23, 22)]"}}],"constants":[0.33,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c45_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(4, 4, 5)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(4, 4, 5)]"}}],"constants":[1.3,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c46_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(4, 5, 4)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(4, 5, 4)]"}}],"constants":[1.3,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c47_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(13, 9, 16)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(13, 9, 16)]"}}],"constants":[0.74,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c48_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(13, 16, 9)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(13, 16, 9)]"}}],"constants":[0.74,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c49_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(15, 12, 13)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(15, 12, 13)]"}}],"constants":[0.74,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c50_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(15, 13, 12)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(15, 13, 12)]"}}],"constants":[0.74,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c51_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(2, 2, 3)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(2, 2, 3)]"}}],"constants":[1.3,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c52_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(2, 3, 2)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(2, 3, 2)]"}}],"constants":[1.3,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c53_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(27, 24, 25)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(27, 24, 25)]"}}],"constants":[0.13,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c54_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(27, 25, 24)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(27, 25, 24)]"}}],"constants":[0.13,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c55_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(21, 18, 16)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(21, 18, 16)]"}}],"constants":[1.0,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c56_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(21, 16, 18)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(21, 16, 18)]"}}],"constants":[1.0,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c57_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(26, 23, 24)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(26, 23, 24)]"}}],"constants":[0.13,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c58_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(26, 24, 23)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(26, 24, 23)]"}}],"constants":[0.13,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c59_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(10, 8, 9)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(10, 8, 9)]"}}],"constants":[0.74,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c60_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(10, 9, 8)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(10, 9, 8)]"}}],"constants":[0.74,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c61_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(18, 14, 20)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(18, 14, 20)]"}}],"constants":[0.47,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c62_2","function":{"type":"VectorAffineFunction","terms":[{"output_index":2,"scalar_term":{"coefficient":1.0,"variable":"0_p[(18, 20, 14)]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_q[(18, 20, 14)]"}}],"constants":[0.47,0.0,0.0]},"set":{"type":"SecondOrderCone","dimension":3}},{"name":"c1_4","function":{"type":"VectorAffineFunction","terms":[{"output_index":1,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[18]"}},{"output_index":2,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[16]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_wr[(18, 16)]"}},{"output_index":4,"scalar_term":{"coefficient":1.0,"variable":"0_wi[(18, 16)]"}}],"constants":[0.0,0.0,0.0,0.0]},"set":{"type":"RotatedSecondOrderCone","dimension":4}},{"name":"c2_4","function":{"type":"VectorAffineFunction","terms":[{"output_index":1,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[19]"}},{"output_index":2,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[28]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_wr[(19, 28)]"}},{"output_index":4,"scalar_term":{"coefficient":1.0,"variable":"0_wi[(19, 28)]"}}],"constants":[0.0,0.0,0.0,0.0]},"set":{"type":"RotatedSecondOrderCone","dimension":4}},{"name":"c3_4","function":{"type":"VectorAffineFunction","terms":[{"output_index":1,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[11]"}},{"output_index":2,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[18]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_wr[(11, 18)]"}},{"output_index":4,"scalar_term":{"coefficient":1.0,"variable":"0_wi[(11, 18)]"}}],"constants":[0.0,0.0,0.0,0.0]},"set":{"type":"RotatedSecondOrderCone","dimension":4}},{"name":"c4_4","function":{"type":"VectorAffineFunction","terms":[{"output_index":1,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[4]"}},{"output_index":2,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[5]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_wr[(4, 5)]"}},{"output_index":4,"scalar_term":{"coefficient":1.0,"variable":"0_wi[(4, 5)]"}}],"constants":[0.0,0.0,0.0,0.0]},"set":{"type":"RotatedSecondOrderCone","dimension":4}},{"name":"c5_4","function":{"type":"VectorAffineFunction","terms":[{"output_index":1,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[23]"}},{"output_index":2,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[24]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_wr[(23, 24)]"}},{"output_index":4,"scalar_term":{"coefficient":1.0,"variable":"0_wi[(23, 24)]"}}],"constants":[0.0,0.0,0.0,0.0]},"set":{"type":"RotatedSecondOrderCone","dimension":4}},{"name":"c6_4","function":{"type":"VectorAffineFunction","terms":[{"output_index":1,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[12]"}},{"output_index":2,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[13]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_wr[(12, 13)]"}},{"output_index":4,"scalar_term":{"coefficient":1.0,"variable":"0_wi[(12, 13)]"}}],"constants":[0.0,0.0,0.0,0.0]},"set":{"type":"RotatedSecondOrderCone","dimension":4}},{"name":"c7_4","function":{"type":"VectorAffineFunction","terms":[{"output_index":1,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[9]"}},{"output_index":2,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[10]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_wr[(9, 10)]"}},{"output_index":4,"scalar_term":{"coefficient":1.0,"variable":"0_wi[(9, 10)]"}}],"constants":[0.0,0.0,0.0,0.0]},"set":{"type":"RotatedSecondOrderCone","dimension":4}},{"name":"c8_4","function":{"type":"VectorAffineFunction","terms":[{"output_index":1,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[9]"}},{"output_index":2,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[12]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_wr[(9, 12)]"}},{"output_index":4,"scalar_term":{"coefficient":1.0,"variable":"0_wi[(9, 12)]"}}],"constants":[0.0,0.0,0.0,0.0]},"set":{"type":"RotatedSecondOrderCone","dimension":4}},{"name":"c9_4","function":{"type":"VectorAffineFunction","terms":[{"output_index":1,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[25]"}},{"output_index":2,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[26]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_wr[(25, 26)]"}},{"output_index":4,"scalar_term":{"coefficient":1.0,"variable":"0_wi[(25, 26)]"}}],"constants":[0.0,0.0,0.0,0.0]},"set":{"type":"RotatedSecondOrderCone","dimension":4}},{"name":"c10_4","function":{"type":"VectorAffineFunction","terms":[{"output_index":1,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[7]"}},{"output_index":2,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[8]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_wr[(7, 8)]"}},{"output_index":4,"scalar_term":{"coefficient":1.0,"variable":"0_wi[(7, 8)]"}}],"constants":[0.0,0.0,0.0,0.0]},"set":{"type":"RotatedSecondOrderCone","dimension":4}},{"name":"c11_4","function":{"type":"VectorAffineFunction","terms":[{"output_index":1,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[21]"}},{"output_index":2,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[22]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_wr[(21, 22)]"}},{"output_index":4,"scalar_term":{"coefficient":1.0,"variable":"0_wi[(21, 22)]"}}],"constants":[0.0,0.0,0.0,0.0]},"set":{"type":"RotatedSecondOrderCone","dimension":4}},{"name":"c12_4","function":{"type":"VectorAffineFunction","terms":[{"output_index":1,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[5]"}},{"output_index":2,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[11]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_wr[(5, 11)]"}},{"output_index":4,"scalar_term":{"coefficient":1.0,"variable":"0_wi[(5, 11)]"}}],"constants":[0.0,0.0,0.0,0.0]},"set":{"type":"RotatedSecondOrderCone","dimension":4}},{"name":"c13_4","function":{"type":"VectorAffineFunction","terms":[{"output_index":1,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[14]"}},{"output_index":2,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[15]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_wr[(14, 15)]"}},{"output_index":4,"scalar_term":{"coefficient":1.0,"variable":"0_wi[(14, 15)]"}}],"constants":[0.0,0.0,0.0,0.0]},"set":{"type":"RotatedSecondOrderCone","dimension":4}},{"name":"c14_4","function":{"type":"VectorAffineFunction","terms":[{"output_index":1,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[7]"}},{"output_index":2,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[10]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_wr[(7, 10)]"}},{"output_index":4,"scalar_term":{"coefficient":1.0,"variable":"0_wi[(7, 10)]"}}],"constants":[0.0,0.0,0.0,0.0]},"set":{"type":"RotatedSecondOrderCone","dimension":4}},{"name":"c15_4","function":{"type":"VectorAffineFunction","terms":[{"output_index":1,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[8]"}},{"output_index":2,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[9]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_wr[(8, 9)]"}},{"output_index":4,"scalar_term":{"coefficient":1.0,"variable":"0_wi[(8, 9)]"}}],"constants":[0.0,0.0,0.0,0.0]},"set":{"type":"RotatedSecondOrderCone","dimension":4}},{"name":"c16_4","function":{"type":"VectorAffineFunction","terms":[{"output_index":1,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[5]"}},{"output_index":2,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[6]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_wr[(5, 6)]"}},{"output_index":4,"scalar_term":{"coefficient":1.0,"variable":"0_wi[(5, 6)]"}}],"constants":[0.0,0.0,0.0,0.0]},"set":{"type":"RotatedSecondOrderCone","dimension":4}},{"name":"c17_4","function":{"type":"VectorAffineFunction","terms":[{"output_index":1,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[2]"}},{"output_index":2,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[1]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_wr[(2, 1)]"}},{"output_index":4,"scalar_term":{"coefficient":1.0,"variable":"0_wi[(2, 1)]"}}],"constants":[0.0,0.0,0.0,0.0]},"set":{"type":"RotatedSecondOrderCone","dimension":4}},{"name":"c18_4","function":{"type":"VectorAffineFunction","terms":[{"output_index":1,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[3]"}},{"output_index":2,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[4]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_wr[(3, 4)]"}},{"output_index":4,"scalar_term":{"coefficient":1.0,"variable":"0_wi[(3, 4)]"}}],"constants":[0.0,0.0,0.0,0.0]},"set":{"type":"RotatedSecondOrderCone","dimension":4}},{"name":"c19_4","function":{"type":"VectorAffineFunction","terms":[{"output_index":1,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[9]"}},{"output_index":2,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[16]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_wr[(9, 16)]"}},{"output_index":4,"scalar_term":{"coefficient":1.0,"variable":"0_wi[(9, 16)]"}}],"constants":[0.0,0.0,0.0,0.0]},"set":{"type":"RotatedSecondOrderCone","dimension":4}},{"name":"c20_4","function":{"type":"VectorAffineFunction","terms":[{"output_index":1,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[14]"}},{"output_index":2,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[20]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_wr[(14, 20)]"}},{"output_index":4,"scalar_term":{"coefficient":1.0,"variable":"0_wi[(14, 20)]"}}],"constants":[0.0,0.0,0.0,0.0]},"set":{"type":"RotatedSecondOrderCone","dimension":4}},{"name":"c21_4","function":{"type":"VectorAffineFunction","terms":[{"output_index":1,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[16]"}},{"output_index":2,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[19]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_wr[(16, 19)]"}},{"output_index":4,"scalar_term":{"coefficient":1.0,"variable":"0_wi[(16, 19)]"}}],"constants":[0.0,0.0,0.0,0.0]},"set":{"type":"RotatedSecondOrderCone","dimension":4}},{"name":"c22_4","function":{"type":"VectorAffineFunction","terms":[{"output_index":1,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[14]"}},{"output_index":2,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[16]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_wr[(14, 16)]"}},{"output_index":4,"scalar_term":{"coefficient":1.0,"variable":"0_wi[(14, 16)]"}}],"constants":[0.0,0.0,0.0,0.0]},"set":{"type":"RotatedSecondOrderCone","dimension":4}},{"name":"c23_4","function":{"type":"VectorAffineFunction","terms":[{"output_index":1,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[2]"}},{"output_index":2,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[3]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_wr[(2, 3)]"}},{"output_index":4,"scalar_term":{"coefficient":1.0,"variable":"0_wi[(2, 3)]"}}],"constants":[0.0,0.0,0.0,0.0]},"set":{"type":"RotatedSecondOrderCone","dimension":4}},{"name":"c24_4","function":{"type":"VectorAffineFunction","terms":[{"output_index":1,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[16]"}},{"output_index":2,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[17]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_wr[(16, 17)]"}},{"output_index":4,"scalar_term":{"coefficient":1.0,"variable":"0_wi[(16, 17)]"}}],"constants":[0.0,0.0,0.0,0.0]},"set":{"type":"RotatedSecondOrderCone","dimension":4}},{"name":"c25_4","function":{"type":"VectorAffineFunction","terms":[{"output_index":1,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[24]"}},{"output_index":2,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[25]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_wr[(24, 25)]"}},{"output_index":4,"scalar_term":{"coefficient":1.0,"variable":"0_wi[(24, 25)]"}}],"constants":[0.0,0.0,0.0,0.0]},"set":{"type":"RotatedSecondOrderCone","dimension":4}},{"name":"c26_4","function":{"type":"VectorAffineFunction","terms":[{"output_index":1,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[13]"}},{"output_index":2,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[14]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_wr[(13, 14)]"}},{"output_index":4,"scalar_term":{"coefficient":1.0,"variable":"0_wi[(13, 14)]"}}],"constants":[0.0,0.0,0.0,0.0]},"set":{"type":"RotatedSecondOrderCone","dimension":4}},{"name":"c27_4","function":{"type":"VectorAffineFunction","terms":[{"output_index":1,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[22]"}},{"output_index":2,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[23]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_wr[(22, 23)]"}},{"output_index":4,"scalar_term":{"coefficient":1.0,"variable":"0_wi[(22, 23)]"}}],"constants":[0.0,0.0,0.0,0.0]},"set":{"type":"RotatedSecondOrderCone","dimension":4}},{"name":"c28_4","function":{"type":"VectorAffineFunction","terms":[{"output_index":1,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[6]"}},{"output_index":2,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[7]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_wr[(6, 7)]"}},{"output_index":4,"scalar_term":{"coefficient":1.0,"variable":"0_wi[(6, 7)]"}}],"constants":[0.0,0.0,0.0,0.0]},"set":{"type":"RotatedSecondOrderCone","dimension":4}},{"name":"c29_4","function":{"type":"VectorAffineFunction","terms":[{"output_index":1,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[20]"}},{"output_index":2,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[21]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_wr[(20, 21)]"}},{"output_index":4,"scalar_term":{"coefficient":1.0,"variable":"0_wi[(20, 21)]"}}],"constants":[0.0,0.0,0.0,0.0]},"set":{"type":"RotatedSecondOrderCone","dimension":4}},{"name":"c30_4","function":{"type":"VectorAffineFunction","terms":[{"output_index":1,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[17]"}},{"output_index":2,"scalar_term":{"coefficient":0.7071067811865475,"variable":"0_w[27]"}},{"output_index":3,"scalar_term":{"coefficient":1.0,"variable":"0_wr[(17, 27)]"}},{"output_index":4,"scalar_term":{"coefficient":1.0,"variable":"0_wi[(17, 27)]"}}],"constants":[0.0,0.0,0.0,0.0]},"set":{"type":"RotatedSecondOrderCone","dimension":4}},{"function":{"type":"Variable","name":"reservoir[1]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"reservoir[2]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"reservoir[3]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"reservoir[4]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"reservoir[5]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"reservoir[6]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"reservoir[7]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"reservoir[8]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"reservoir[9]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"reservoir[10]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"reservoir[11]_in"},"set":{"type":"EqualTo","value":0.0}},{"function":{"type":"Variable","name":"inflow[1]"},"set":{"type":"EqualTo","value":2.338129891598134}},{"function":{"type":"Variable","name":"inflow[2]"},"set":{"type":"EqualTo","value":19.049733526468252}},{"function":{"type":"Variable","name":"inflow[3]"},"set":{"type":"EqualTo","value":0.48408174580858665}},{"function":{"type":"Variable","name":"inflow[4]"},"set":{"type":"EqualTo","value":5.40128586100095}},{"function":{"type":"Variable","name":"inflow[5]"},"set":{"type":"EqualTo","value":9.16293594438752}},{"function":{"type":"Variable","name":"inflow[6]"},"set":{"type":"EqualTo","value":13.401595443549056}},{"function":{"type":"Variable","name":"inflow[7]"},"set":{"type":"EqualTo","value":0.6835222599450383}},{"function":{"type":"Variable","name":"inflow[8]"},"set":{"type":"EqualTo","value":8.002953930720434}},{"function":{"type":"Variable","name":"inflow[9]"},"set":{"type":"EqualTo","value":6.459871302494316}},{"function":{"type":"Variable","name":"inflow[10]"},"set":{"type":"EqualTo","value":1.8616228172257083}},{"function":{"type":"Variable","name":"inflow[11]"},"set":{"type":"EqualTo","value":3.210450288504671}},{"function":{"type":"Variable","name":"0_w[5]"},"set":{"type":"GreaterThan","lower":0.81}},{"function":{"type":"Variable","name":"0_w[16]"},"set":{"type":"GreaterThan","lower":0.81}},{"function":{"type":"Variable","name":"0_w[20]"},"set":{"type":"GreaterThan","lower":0.81}},{"function":{"type":"Variable","name":"0_w[12]"},"set":{"type":"GreaterThan","lower":0.81}},{"function":{"type":"Variable","name":"0_w[24]"},"set":{"type":"GreaterThan","lower":0.81}},{"function":{"type":"Variable","name":"0_w[28]"},"set":{"type":"GreaterThan","lower":0.81}},{"function":{"type":"Variable","name":"0_w[8]"},"set":{"type":"GreaterThan","lower":0.81}},{"function":{"type":"Variable","name":"0_w[17]"},"set":{"type":"GreaterThan","lower":0.81}},{"function":{"type":"Variable","name":"0_w[1]"},"set":{"type":"GreaterThan","lower":0.81}},{"function":{"type":"Variable","name":"0_w[23]"},"set":{"type":"GreaterThan","lower":0.81}},{"function":{"type":"Variable","name":"0_w[22]"},"set":{"type":"GreaterThan","lower":0.81}},{"function":{"type":"Variable","name":"0_w[19]"},"set":{"type":"GreaterThan","lower":0.81}},{"function":{"type":"Variable","name":"0_w[6]"},"set":{"type":"GreaterThan","lower":0.81}},{"function":{"type":"Variable","name":"0_w[11]"},"set":{"type":"GreaterThan","lower":0.81}},{"function":{"type":"Variable","name":"0_w[9]"},"set":{"type":"GreaterThan","lower":0.81}},{"function":{"type":"Variable","name":"0_w[14]"},"set":{"type":"GreaterThan","lower":0.81}},{"function":{"type":"Variable","name":"0_w[3]"},"set":{"type":"GreaterThan","lower":0.81}},{"function":{"type":"Variable","name":"0_w[7]"},"set":{"type":"GreaterThan","lower":0.81}},{"function":{"type":"Variable","name":"0_w[25]"},"set":{"type":"GreaterThan","lower":0.81}},{"function":{"type":"Variable","name":"0_w[4]"},"set":{"type":"GreaterThan","lower":0.81}},{"function":{"type":"Variable","name":"0_w[13]"},"set":{"type":"GreaterThan","lower":0.81}},{"function":{"type":"Variable","name":"0_w[15]"},"set":{"type":"GreaterThan","lower":0.81}},{"function":{"type":"Variable","name":"0_w[2]"},"set":{"type":"GreaterThan","lower":0.81}},{"function":{"type":"Variable","name":"0_w[27]"},"set":{"type":"GreaterThan","lower":0.81}},{"function":{"type":"Variable","name":"0_w[21]"},"set":{"type":"GreaterThan","lower":0.81}},{"function":{"type":"Variable","name":"0_w[26]"},"set":{"type":"GreaterThan","lower":0.81}},{"function":{"type":"Variable","name":"0_w[10]"},"set":{"type":"GreaterThan","lower":0.81}},{"function":{"type":"Variable","name":"0_w[18]"},"set":{"type":"GreaterThan","lower":0.81}},{"function":{"type":"Variable","name":"0_wr[(18, 16)]"},"set":{"type":"GreaterThan","lower":0.404998282210762}},{"function":{"type":"Variable","name":"0_wr[(19, 28)]"},"set":{"type":"GreaterThan","lower":0.404998282210762}},{"function":{"type":"Variable","name":"0_wr[(11, 18)]"},"set":{"type":"GreaterThan","lower":0.404998282210762}},{"function":{"type":"Variable","name":"0_wr[(4, 5)]"},"set":{"type":"GreaterThan","lower":0.404998282210762}},{"function":{"type":"Variable","name":"0_wr[(23, 24)]"},"set":{"type":"GreaterThan","lower":0.404998282210762}},{"function":{"type":"Variable","name":"0_wr[(12, 13)]"},"set":{"type":"GreaterThan","lower":0.404998282210762}},{"function":{"type":"Variable","name":"0_wr[(9, 10)]"},"set":{"type":"GreaterThan","lower":0.404998282210762}},{"function":{"type":"Variable","name":"0_wr[(9, 12)]"},"set":{"type":"GreaterThan","lower":0.404998282210762}},{"function":{"type":"Variable","name":"0_wr[(25, 26)]"},"set":{"type":"GreaterThan","lower":0.404998282210762}},{"function":{"type":"Variable","name":"0_wr[(7, 8)]"},"set":{"type":"GreaterThan","lower":0.404998282210762}},{"function":{"type":"Variable","name":"0_wr[(21, 22)]"},"set":{"type":"GreaterThan","lower":0.404998282210762}},{"function":{"type":"Variable","name":"0_wr[(5, 11)]"},"set":{"type":"GreaterThan","lower":0.404998282210762}},{"function":{"type":"Variable","name":"0_wr[(14, 15)]"},"set":{"type":"GreaterThan","lower":0.404998282210762}},{"function":{"type":"Variable","name":"0_wr[(7, 10)]"},"set":{"type":"GreaterThan","lower":0.404998282210762}},{"function":{"type":"Variable","name":"0_wr[(8, 9)]"},"set":{"type":"GreaterThan","lower":0.404998282210762}},{"function":{"type":"Variable","name":"0_wr[(5, 6)]"},"set":{"type":"GreaterThan","lower":0.404998282210762}},{"function":{"type":"Variable","name":"0_wr[(2, 1)]"},"set":{"type":"GreaterThan","lower":0.404998282210762}},{"function":{"type":"Variable","name":"0_wr[(3, 4)]"},"set":{"type":"GreaterThan","lower":0.404998282210762}},{"function":{"type":"Variable","name":"0_wr[(9, 16)]"},"set":{"type":"GreaterThan","lower":0.404998282210762}},{"function":{"type":"Variable","name":"0_wr[(14, 20)]"},"set":{"type":"GreaterThan","lower":0.404998282210762}},{"function":{"type":"Variable","name":"0_wr[(16, 19)]"},"set":{"type":"GreaterThan","lower":0.404998282210762}},{"function":{"type":"Variable","name":"0_wr[(14, 16)]"},"set":{"type":"GreaterThan","lower":0.404998282210762}},{"function":{"type":"Variable","name":"0_wr[(2, 3)]"},"set":{"type":"GreaterThan","lower":0.404998282210762}},{"function":{"type":"Variable","name":"0_wr[(16, 17)]"},"set":{"type":"GreaterThan","lower":0.404998282210762}},{"function":{"type":"Variable","name":"0_wr[(24, 25)]"},"set":{"type":"GreaterThan","lower":0.404998282210762}},{"function":{"type":"Variable","name":"0_wr[(13, 14)]"},"set":{"type":"GreaterThan","lower":0.404998282210762}},{"function":{"type":"Variable","name":"0_wr[(22, 23)]"},"set":{"type":"GreaterThan","lower":0.404998282210762}},{"function":{"type":"Variable","name":"0_wr[(6, 7)]"},"set":{"type":"GreaterThan","lower":0.404998282210762}},{"function":{"type":"Variable","name":"0_wr[(20, 21)]"},"set":{"type":"GreaterThan","lower":0.404998282210762}},{"function":{"type":"Variable","name":"0_wr[(17, 27)]"},"set":{"type":"GreaterThan","lower":0.404998282210762}},{"function":{"type":"Variable","name":"0_wi[(18, 16)]"},"set":{"type":"GreaterThan","lower":-1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(19, 28)]"},"set":{"type":"GreaterThan","lower":-1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(11, 18)]"},"set":{"type":"GreaterThan","lower":-1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(4, 5)]"},"set":{"type":"GreaterThan","lower":-1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(23, 24)]"},"set":{"type":"GreaterThan","lower":-1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(12, 13)]"},"set":{"type":"GreaterThan","lower":-1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(9, 10)]"},"set":{"type":"GreaterThan","lower":-1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(9, 12)]"},"set":{"type":"GreaterThan","lower":-1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(25, 26)]"},"set":{"type":"GreaterThan","lower":-1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(7, 8)]"},"set":{"type":"GreaterThan","lower":-1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(21, 22)]"},"set":{"type":"GreaterThan","lower":-1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(5, 11)]"},"set":{"type":"GreaterThan","lower":-1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(14, 15)]"},"set":{"type":"GreaterThan","lower":-1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(7, 10)]"},"set":{"type":"GreaterThan","lower":-1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(8, 9)]"},"set":{"type":"GreaterThan","lower":-1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(5, 6)]"},"set":{"type":"GreaterThan","lower":-1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(2, 1)]"},"set":{"type":"GreaterThan","lower":-1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(3, 4)]"},"set":{"type":"GreaterThan","lower":-1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(9, 16)]"},"set":{"type":"GreaterThan","lower":-1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(14, 20)]"},"set":{"type":"GreaterThan","lower":-1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(16, 19)]"},"set":{"type":"GreaterThan","lower":-1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(14, 16)]"},"set":{"type":"GreaterThan","lower":-1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(2, 3)]"},"set":{"type":"GreaterThan","lower":-1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(16, 17)]"},"set":{"type":"GreaterThan","lower":-1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(24, 25)]"},"set":{"type":"GreaterThan","lower":-1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(13, 14)]"},"set":{"type":"GreaterThan","lower":-1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(22, 23)]"},"set":{"type":"GreaterThan","lower":-1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(6, 7)]"},"set":{"type":"GreaterThan","lower":-1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(20, 21)]"},"set":{"type":"GreaterThan","lower":-1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(17, 27)]"},"set":{"type":"GreaterThan","lower":-1.0478922201020873}},{"function":{"type":"Variable","name":"0_pg[5]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[16]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[20]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[12]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[24]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[28]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[8]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[17]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[30]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[1]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[23]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[32]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[22]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[6]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[19]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[11]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[31]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[9]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[14]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[3]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[29]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[33]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[25]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[7]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[34]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[4]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[13]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[15]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[2]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[27]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[21]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[26]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[10]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_pg[18]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_qg[5]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[16]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[20]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[12]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[24]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[28]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[8]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[17]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[30]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[1]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[23]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[32]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[22]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[6]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[19]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[11]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[31]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[9]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[14]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[3]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[29]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[33]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[25]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[7]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[34]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[4]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[13]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[15]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[2]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[27]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[21]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[26]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[10]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_qg[18]"},"set":{"type":"GreaterThan","lower":-999.0}},{"function":{"type":"Variable","name":"0_p[(5, 5, 6)]"},"set":{"type":"GreaterThan","lower":-0.7}},{"function":{"type":"Variable","name":"0_p[(16, 13, 14)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(20, 16, 17)]"},"set":{"type":"GreaterThan","lower":-0.25}},{"function":{"type":"Variable","name":"0_p[(12, 9, 12)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(24, 21, 22)]"},"set":{"type":"GreaterThan","lower":-0.25}},{"function":{"type":"Variable","name":"0_p[(28, 25, 26)]"},"set":{"type":"GreaterThan","lower":-0.13}},{"function":{"type":"Variable","name":"0_p[(8, 7, 8)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(17, 14, 15)]"},"set":{"type":"GreaterThan","lower":-0.5}},{"function":{"type":"Variable","name":"0_p[(30, 19, 28)]"},"set":{"type":"GreaterThan","lower":-1.0}},{"function":{"type":"Variable","name":"0_p[(1, 2, 1)]"},"set":{"type":"GreaterThan","lower":-0.7}},{"function":{"type":"Variable","name":"0_p[(23, 20, 21)]"},"set":{"type":"GreaterThan","lower":-0.47}},{"function":{"type":"Variable","name":"0_p[(22, 16, 19)]"},"set":{"type":"GreaterThan","lower":-1.06}},{"function":{"type":"Variable","name":"0_p[(19, 14, 16)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(6, 5, 11)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_p[(11, 9, 10)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(31, 19, 28)]"},"set":{"type":"GreaterThan","lower":-1.0}},{"function":{"type":"Variable","name":"0_p[(9, 7, 10)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(14, 11, 18)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_p[(3, 3, 4)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_p[(29, 17, 27)]"},"set":{"type":"GreaterThan","lower":-2.0}},{"function":{"type":"Variable","name":"0_p[(7, 6, 7)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(25, 22, 23)]"},"set":{"type":"GreaterThan","lower":-0.33}},{"function":{"type":"Variable","name":"0_p[(4, 4, 5)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_p[(13, 9, 16)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(15, 12, 13)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(2, 2, 3)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_p[(27, 24, 25)]"},"set":{"type":"GreaterThan","lower":-0.13}},{"function":{"type":"Variable","name":"0_p[(21, 18, 16)]"},"set":{"type":"GreaterThan","lower":-1.0}},{"function":{"type":"Variable","name":"0_p[(26, 23, 24)]"},"set":{"type":"GreaterThan","lower":-0.13}},{"function":{"type":"Variable","name":"0_p[(10, 8, 9)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(18, 14, 20)]"},"set":{"type":"GreaterThan","lower":-0.47}},{"function":{"type":"Variable","name":"0_p[(5, 6, 5)]"},"set":{"type":"GreaterThan","lower":-0.7}},{"function":{"type":"Variable","name":"0_p[(16, 14, 13)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(20, 17, 16)]"},"set":{"type":"GreaterThan","lower":-0.25}},{"function":{"type":"Variable","name":"0_p[(12, 12, 9)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(24, 22, 21)]"},"set":{"type":"GreaterThan","lower":-0.25}},{"function":{"type":"Variable","name":"0_p[(28, 26, 25)]"},"set":{"type":"GreaterThan","lower":-0.13}},{"function":{"type":"Variable","name":"0_p[(8, 8, 7)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(17, 15, 14)]"},"set":{"type":"GreaterThan","lower":-0.5}},{"function":{"type":"Variable","name":"0_p[(30, 28, 19)]"},"set":{"type":"GreaterThan","lower":-1.0}},{"function":{"type":"Variable","name":"0_p[(1, 1, 2)]"},"set":{"type":"GreaterThan","lower":-0.7}},{"function":{"type":"Variable","name":"0_p[(23, 21, 20)]"},"set":{"type":"GreaterThan","lower":-0.47}},{"function":{"type":"Variable","name":"0_p[(22, 19, 16)]"},"set":{"type":"GreaterThan","lower":-1.06}},{"function":{"type":"Variable","name":"0_p[(19, 16, 14)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(6, 11, 5)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_p[(11, 10, 9)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(31, 28, 19)]"},"set":{"type":"GreaterThan","lower":-1.0}},{"function":{"type":"Variable","name":"0_p[(9, 10, 7)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(14, 18, 11)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_p[(3, 4, 3)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_p[(29, 27, 17)]"},"set":{"type":"GreaterThan","lower":-2.0}},{"function":{"type":"Variable","name":"0_p[(7, 7, 6)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(25, 23, 22)]"},"set":{"type":"GreaterThan","lower":-0.33}},{"function":{"type":"Variable","name":"0_p[(4, 5, 4)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_p[(13, 16, 9)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(15, 13, 12)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(2, 3, 2)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_p[(27, 25, 24)]"},"set":{"type":"GreaterThan","lower":-0.13}},{"function":{"type":"Variable","name":"0_p[(21, 16, 18)]"},"set":{"type":"GreaterThan","lower":-1.0}},{"function":{"type":"Variable","name":"0_p[(26, 24, 23)]"},"set":{"type":"GreaterThan","lower":-0.13}},{"function":{"type":"Variable","name":"0_p[(10, 9, 8)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_p[(18, 20, 14)]"},"set":{"type":"GreaterThan","lower":-0.47}},{"function":{"type":"Variable","name":"0_q[(5, 5, 6)]"},"set":{"type":"GreaterThan","lower":-0.7}},{"function":{"type":"Variable","name":"0_q[(16, 13, 14)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(20, 16, 17)]"},"set":{"type":"GreaterThan","lower":-0.25}},{"function":{"type":"Variable","name":"0_q[(12, 9, 12)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(24, 21, 22)]"},"set":{"type":"GreaterThan","lower":-0.25}},{"function":{"type":"Variable","name":"0_q[(28, 25, 26)]"},"set":{"type":"GreaterThan","lower":-0.13}},{"function":{"type":"Variable","name":"0_q[(8, 7, 8)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(17, 14, 15)]"},"set":{"type":"GreaterThan","lower":-0.5}},{"function":{"type":"Variable","name":"0_q[(30, 19, 28)]"},"set":{"type":"GreaterThan","lower":-1.0}},{"function":{"type":"Variable","name":"0_q[(1, 2, 1)]"},"set":{"type":"GreaterThan","lower":-0.7}},{"function":{"type":"Variable","name":"0_q[(23, 20, 21)]"},"set":{"type":"GreaterThan","lower":-0.47}},{"function":{"type":"Variable","name":"0_q[(22, 16, 19)]"},"set":{"type":"GreaterThan","lower":-1.06}},{"function":{"type":"Variable","name":"0_q[(19, 14, 16)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(6, 5, 11)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_q[(11, 9, 10)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(31, 19, 28)]"},"set":{"type":"GreaterThan","lower":-1.0}},{"function":{"type":"Variable","name":"0_q[(9, 7, 10)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(14, 11, 18)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_q[(3, 3, 4)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_q[(29, 17, 27)]"},"set":{"type":"GreaterThan","lower":-2.0}},{"function":{"type":"Variable","name":"0_q[(7, 6, 7)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(25, 22, 23)]"},"set":{"type":"GreaterThan","lower":-0.33}},{"function":{"type":"Variable","name":"0_q[(4, 4, 5)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_q[(13, 9, 16)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(15, 12, 13)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(2, 2, 3)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_q[(27, 24, 25)]"},"set":{"type":"GreaterThan","lower":-0.13}},{"function":{"type":"Variable","name":"0_q[(21, 18, 16)]"},"set":{"type":"GreaterThan","lower":-1.0}},{"function":{"type":"Variable","name":"0_q[(26, 23, 24)]"},"set":{"type":"GreaterThan","lower":-0.13}},{"function":{"type":"Variable","name":"0_q[(10, 8, 9)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(18, 14, 20)]"},"set":{"type":"GreaterThan","lower":-0.47}},{"function":{"type":"Variable","name":"0_q[(5, 6, 5)]"},"set":{"type":"GreaterThan","lower":-0.7}},{"function":{"type":"Variable","name":"0_q[(16, 14, 13)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(20, 17, 16)]"},"set":{"type":"GreaterThan","lower":-0.25}},{"function":{"type":"Variable","name":"0_q[(12, 12, 9)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(24, 22, 21)]"},"set":{"type":"GreaterThan","lower":-0.25}},{"function":{"type":"Variable","name":"0_q[(28, 26, 25)]"},"set":{"type":"GreaterThan","lower":-0.13}},{"function":{"type":"Variable","name":"0_q[(8, 8, 7)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(17, 15, 14)]"},"set":{"type":"GreaterThan","lower":-0.5}},{"function":{"type":"Variable","name":"0_q[(30, 28, 19)]"},"set":{"type":"GreaterThan","lower":-1.0}},{"function":{"type":"Variable","name":"0_q[(1, 1, 2)]"},"set":{"type":"GreaterThan","lower":-0.7}},{"function":{"type":"Variable","name":"0_q[(23, 21, 20)]"},"set":{"type":"GreaterThan","lower":-0.47}},{"function":{"type":"Variable","name":"0_q[(22, 19, 16)]"},"set":{"type":"GreaterThan","lower":-1.06}},{"function":{"type":"Variable","name":"0_q[(19, 16, 14)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(6, 11, 5)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_q[(11, 10, 9)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(31, 28, 19)]"},"set":{"type":"GreaterThan","lower":-1.0}},{"function":{"type":"Variable","name":"0_q[(9, 10, 7)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(14, 18, 11)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_q[(3, 4, 3)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_q[(29, 27, 17)]"},"set":{"type":"GreaterThan","lower":-2.0}},{"function":{"type":"Variable","name":"0_q[(7, 7, 6)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(25, 23, 22)]"},"set":{"type":"GreaterThan","lower":-0.33}},{"function":{"type":"Variable","name":"0_q[(4, 5, 4)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_q[(13, 16, 9)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(15, 13, 12)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(2, 3, 2)]"},"set":{"type":"GreaterThan","lower":-1.3}},{"function":{"type":"Variable","name":"0_q[(27, 25, 24)]"},"set":{"type":"GreaterThan","lower":-0.13}},{"function":{"type":"Variable","name":"0_q[(21, 16, 18)]"},"set":{"type":"GreaterThan","lower":-1.0}},{"function":{"type":"Variable","name":"0_q[(26, 24, 23)]"},"set":{"type":"GreaterThan","lower":-0.13}},{"function":{"type":"Variable","name":"0_q[(10, 9, 8)]"},"set":{"type":"GreaterThan","lower":-0.74}},{"function":{"type":"Variable","name":"0_q[(18, 20, 14)]"},"set":{"type":"GreaterThan","lower":-0.47}},{"function":{"type":"Variable","name":"reservoir[1]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"reservoir[2]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"reservoir[3]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"reservoir[4]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"reservoir[5]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"reservoir[6]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"reservoir[7]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"reservoir[8]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"reservoir[9]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"reservoir[10]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"reservoir[11]_out"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[1]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[2]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[3]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[4]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[5]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[6]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[7]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[8]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[9]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[10]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_volume_violation[11]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[1]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[2]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[3]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[4]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[5]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[6]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[7]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[8]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[9]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[10]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"outflow[11]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[1]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[2]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[3]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[4]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[5]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[6]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[7]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[8]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[9]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[10]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"spill[11]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[1]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[2]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[3]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[4]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[5]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[6]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[7]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[8]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[9]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[10]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"min_outflow_violation[11]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[1]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[2]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[3]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[4]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[5]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[6]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[7]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[8]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[9]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[10]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[11]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[12]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[13]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[14]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[15]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[16]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[17]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[18]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[19]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[20]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[21]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[22]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[23]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[24]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[25]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[26]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[27]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"deficit[28]"},"set":{"type":"GreaterThan","lower":0.0}},{"function":{"type":"Variable","name":"0_w[5]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_w[16]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_w[20]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_w[12]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_w[24]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_w[28]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_w[8]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_w[17]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_w[1]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_w[23]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_w[22]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_w[19]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_w[6]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_w[11]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_w[9]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_w[14]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_w[3]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_w[7]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_w[25]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_w[4]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_w[13]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_w[15]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_w[2]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_w[27]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_w[21]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_w[26]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_w[10]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_w[18]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_wr[(18, 16)]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_wr[(19, 28)]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_wr[(11, 18)]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_wr[(4, 5)]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_wr[(23, 24)]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_wr[(12, 13)]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_wr[(9, 10)]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_wr[(9, 12)]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_wr[(25, 26)]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_wr[(7, 8)]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_wr[(21, 22)]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_wr[(5, 11)]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_wr[(14, 15)]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_wr[(7, 10)]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_wr[(8, 9)]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_wr[(5, 6)]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_wr[(2, 1)]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_wr[(3, 4)]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_wr[(9, 16)]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_wr[(14, 20)]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_wr[(16, 19)]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_wr[(14, 16)]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_wr[(2, 3)]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_wr[(16, 17)]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_wr[(24, 25)]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_wr[(13, 14)]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_wr[(22, 23)]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_wr[(6, 7)]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_wr[(20, 21)]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_wr[(17, 27)]"},"set":{"type":"LessThan","upper":1.2100000000000002}},{"function":{"type":"Variable","name":"0_wi[(18, 16)]"},"set":{"type":"LessThan","upper":1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(19, 28)]"},"set":{"type":"LessThan","upper":1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(11, 18)]"},"set":{"type":"LessThan","upper":1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(4, 5)]"},"set":{"type":"LessThan","upper":1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(23, 24)]"},"set":{"type":"LessThan","upper":1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(12, 13)]"},"set":{"type":"LessThan","upper":1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(9, 10)]"},"set":{"type":"LessThan","upper":1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(9, 12)]"},"set":{"type":"LessThan","upper":1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(25, 26)]"},"set":{"type":"LessThan","upper":1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(7, 8)]"},"set":{"type":"LessThan","upper":1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(21, 22)]"},"set":{"type":"LessThan","upper":1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(5, 11)]"},"set":{"type":"LessThan","upper":1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(14, 15)]"},"set":{"type":"LessThan","upper":1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(7, 10)]"},"set":{"type":"LessThan","upper":1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(8, 9)]"},"set":{"type":"LessThan","upper":1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(5, 6)]"},"set":{"type":"LessThan","upper":1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(2, 1)]"},"set":{"type":"LessThan","upper":1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(3, 4)]"},"set":{"type":"LessThan","upper":1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(9, 16)]"},"set":{"type":"LessThan","upper":1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(14, 20)]"},"set":{"type":"LessThan","upper":1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(16, 19)]"},"set":{"type":"LessThan","upper":1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(14, 16)]"},"set":{"type":"LessThan","upper":1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(2, 3)]"},"set":{"type":"LessThan","upper":1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(16, 17)]"},"set":{"type":"LessThan","upper":1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(24, 25)]"},"set":{"type":"LessThan","upper":1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(13, 14)]"},"set":{"type":"LessThan","upper":1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(22, 23)]"},"set":{"type":"LessThan","upper":1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(6, 7)]"},"set":{"type":"LessThan","upper":1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(20, 21)]"},"set":{"type":"LessThan","upper":1.0478922201020873}},{"function":{"type":"Variable","name":"0_wi[(17, 27)]"},"set":{"type":"LessThan","upper":1.0478922201020873}},{"function":{"type":"Variable","name":"0_pg[5]"},"set":{"type":"LessThan","upper":0.153}},{"function":{"type":"Variable","name":"0_pg[16]"},"set":{"type":"LessThan","upper":0.149}},{"function":{"type":"Variable","name":"0_pg[20]"},"set":{"type":"LessThan","upper":0.07339999999999999}},{"function":{"type":"Variable","name":"0_pg[12]"},"set":{"type":"LessThan","upper":0.3381}},{"function":{"type":"Variable","name":"0_pg[24]"},"set":{"type":"LessThan","upper":0.72}},{"function":{"type":"Variable","name":"0_pg[28]"},"set":{"type":"LessThan","upper":0.7090000000000001}},{"function":{"type":"Variable","name":"0_pg[8]"},"set":{"type":"LessThan","upper":0.1888}},{"function":{"type":"Variable","name":"0_pg[17]"},"set":{"type":"LessThan","upper":0.149}},{"function":{"type":"Variable","name":"0_pg[30]"},"set":{"type":"LessThan","upper":0.04}},{"function":{"type":"Variable","name":"0_pg[1]"},"set":{"type":"LessThan","upper":0.1826}},{"function":{"type":"Variable","name":"0_pg[23]"},"set":{"type":"LessThan","upper":0.10800000000000001}},{"function":{"type":"Variable","name":"0_pg[32]"},"set":{"type":"LessThan","upper":0.4917}},{"function":{"type":"Variable","name":"0_pg[22]"},"set":{"type":"LessThan","upper":0.1494}},{"function":{"type":"Variable","name":"0_pg[6]"},"set":{"type":"LessThan","upper":0.1696}},{"function":{"type":"Variable","name":"0_pg[19]"},"set":{"type":"LessThan","upper":0.07339999999999999}},{"function":{"type":"Variable","name":"0_pg[11]"},"set":{"type":"LessThan","upper":0.3381}},{"function":{"type":"Variable","name":"0_pg[31]"},"set":{"type":"LessThan","upper":0.3367}},{"function":{"type":"Variable","name":"0_pg[9]"},"set":{"type":"LessThan","upper":0.5175}},{"function":{"type":"Variable","name":"0_pg[14]"},"set":{"type":"LessThan","upper":0.4497}},{"function":{"type":"Variable","name":"0_pg[3]"},"set":{"type":"LessThan","upper":0.1523}},{"function":{"type":"Variable","name":"0_pg[29]"},"set":{"type":"LessThan","upper":1.08}},{"function":{"type":"Variable","name":"0_pg[33]"},"set":{"type":"LessThan","upper":0.0101}},{"function":{"type":"Variable","name":"0_pg[25]"},"set":{"type":"LessThan","upper":0.54}},{"function":{"type":"Variable","name":"0_pg[7]"},"set":{"type":"LessThan","upper":0.1757}},{"function":{"type":"Variable","name":"0_pg[34]"},"set":{"type":"LessThan","upper":0.081}},{"function":{"type":"Variable","name":"0_pg[4]"},"set":{"type":"LessThan","upper":0.1623}},{"function":{"type":"Variable","name":"0_pg[13]"},"set":{"type":"LessThan","upper":0.4497}},{"function":{"type":"Variable","name":"0_pg[15]"},"set":{"type":"LessThan","upper":0.1483}},{"function":{"type":"Variable","name":"0_pg[2]"},"set":{"type":"LessThan","upper":0.1593}},{"function":{"type":"Variable","name":"0_pg[27]"},"set":{"type":"LessThan","upper":0.184}},{"function":{"type":"Variable","name":"0_pg[21]"},"set":{"type":"LessThan","upper":0.1134}},{"function":{"type":"Variable","name":"0_pg[26]"},"set":{"type":"LessThan","upper":0.076}},{"function":{"type":"Variable","name":"0_pg[10]"},"set":{"type":"LessThan","upper":0.5175}},{"function":{"type":"Variable","name":"0_pg[18]"},"set":{"type":"LessThan","upper":0.149}},{"function":{"type":"Variable","name":"0_qg[5]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[16]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[20]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[12]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[24]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[28]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[8]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[17]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[30]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[1]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[23]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[32]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[22]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[6]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[19]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[11]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[31]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[9]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[14]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[3]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[29]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[33]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[25]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[7]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[34]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[4]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[13]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[15]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[2]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[27]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[21]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[26]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[10]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_qg[18]"},"set":{"type":"LessThan","upper":999.0}},{"function":{"type":"Variable","name":"0_p[(5, 5, 6)]"},"set":{"type":"LessThan","upper":0.7}},{"function":{"type":"Variable","name":"0_p[(16, 13, 14)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(20, 16, 17)]"},"set":{"type":"LessThan","upper":0.25}},{"function":{"type":"Variable","name":"0_p[(12, 9, 12)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(24, 21, 22)]"},"set":{"type":"LessThan","upper":0.25}},{"function":{"type":"Variable","name":"0_p[(28, 25, 26)]"},"set":{"type":"LessThan","upper":0.13}},{"function":{"type":"Variable","name":"0_p[(8, 7, 8)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(17, 14, 15)]"},"set":{"type":"LessThan","upper":0.5}},{"function":{"type":"Variable","name":"0_p[(30, 19, 28)]"},"set":{"type":"LessThan","upper":1.0}},{"function":{"type":"Variable","name":"0_p[(1, 2, 1)]"},"set":{"type":"LessThan","upper":0.7}},{"function":{"type":"Variable","name":"0_p[(23, 20, 21)]"},"set":{"type":"LessThan","upper":0.47}},{"function":{"type":"Variable","name":"0_p[(22, 16, 19)]"},"set":{"type":"LessThan","upper":1.06}},{"function":{"type":"Variable","name":"0_p[(19, 14, 16)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(6, 5, 11)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_p[(11, 9, 10)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(31, 19, 28)]"},"set":{"type":"LessThan","upper":1.0}},{"function":{"type":"Variable","name":"0_p[(9, 7, 10)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(14, 11, 18)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_p[(3, 3, 4)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_p[(29, 17, 27)]"},"set":{"type":"LessThan","upper":2.0}},{"function":{"type":"Variable","name":"0_p[(7, 6, 7)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(25, 22, 23)]"},"set":{"type":"LessThan","upper":0.33}},{"function":{"type":"Variable","name":"0_p[(4, 4, 5)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_p[(13, 9, 16)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(15, 12, 13)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(2, 2, 3)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_p[(27, 24, 25)]"},"set":{"type":"LessThan","upper":0.13}},{"function":{"type":"Variable","name":"0_p[(21, 18, 16)]"},"set":{"type":"LessThan","upper":1.0}},{"function":{"type":"Variable","name":"0_p[(26, 23, 24)]"},"set":{"type":"LessThan","upper":0.13}},{"function":{"type":"Variable","name":"0_p[(10, 8, 9)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(18, 14, 20)]"},"set":{"type":"LessThan","upper":0.47}},{"function":{"type":"Variable","name":"0_p[(5, 6, 5)]"},"set":{"type":"LessThan","upper":0.7}},{"function":{"type":"Variable","name":"0_p[(16, 14, 13)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(20, 17, 16)]"},"set":{"type":"LessThan","upper":0.25}},{"function":{"type":"Variable","name":"0_p[(12, 12, 9)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(24, 22, 21)]"},"set":{"type":"LessThan","upper":0.25}},{"function":{"type":"Variable","name":"0_p[(28, 26, 25)]"},"set":{"type":"LessThan","upper":0.13}},{"function":{"type":"Variable","name":"0_p[(8, 8, 7)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(17, 15, 14)]"},"set":{"type":"LessThan","upper":0.5}},{"function":{"type":"Variable","name":"0_p[(30, 28, 19)]"},"set":{"type":"LessThan","upper":1.0}},{"function":{"type":"Variable","name":"0_p[(1, 1, 2)]"},"set":{"type":"LessThan","upper":0.7}},{"function":{"type":"Variable","name":"0_p[(23, 21, 20)]"},"set":{"type":"LessThan","upper":0.47}},{"function":{"type":"Variable","name":"0_p[(22, 19, 16)]"},"set":{"type":"LessThan","upper":1.06}},{"function":{"type":"Variable","name":"0_p[(19, 16, 14)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(6, 11, 5)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_p[(11, 10, 9)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(31, 28, 19)]"},"set":{"type":"LessThan","upper":1.0}},{"function":{"type":"Variable","name":"0_p[(9, 10, 7)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(14, 18, 11)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_p[(3, 4, 3)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_p[(29, 27, 17)]"},"set":{"type":"LessThan","upper":2.0}},{"function":{"type":"Variable","name":"0_p[(7, 7, 6)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(25, 23, 22)]"},"set":{"type":"LessThan","upper":0.33}},{"function":{"type":"Variable","name":"0_p[(4, 5, 4)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_p[(13, 16, 9)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(15, 13, 12)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(2, 3, 2)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_p[(27, 25, 24)]"},"set":{"type":"LessThan","upper":0.13}},{"function":{"type":"Variable","name":"0_p[(21, 16, 18)]"},"set":{"type":"LessThan","upper":1.0}},{"function":{"type":"Variable","name":"0_p[(26, 24, 23)]"},"set":{"type":"LessThan","upper":0.13}},{"function":{"type":"Variable","name":"0_p[(10, 9, 8)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_p[(18, 20, 14)]"},"set":{"type":"LessThan","upper":0.47}},{"function":{"type":"Variable","name":"0_q[(5, 5, 6)]"},"set":{"type":"LessThan","upper":0.7}},{"function":{"type":"Variable","name":"0_q[(16, 13, 14)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(20, 16, 17)]"},"set":{"type":"LessThan","upper":0.25}},{"function":{"type":"Variable","name":"0_q[(12, 9, 12)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(24, 21, 22)]"},"set":{"type":"LessThan","upper":0.25}},{"function":{"type":"Variable","name":"0_q[(28, 25, 26)]"},"set":{"type":"LessThan","upper":0.13}},{"function":{"type":"Variable","name":"0_q[(8, 7, 8)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(17, 14, 15)]"},"set":{"type":"LessThan","upper":0.5}},{"function":{"type":"Variable","name":"0_q[(30, 19, 28)]"},"set":{"type":"LessThan","upper":1.0}},{"function":{"type":"Variable","name":"0_q[(1, 2, 1)]"},"set":{"type":"LessThan","upper":0.7}},{"function":{"type":"Variable","name":"0_q[(23, 20, 21)]"},"set":{"type":"LessThan","upper":0.47}},{"function":{"type":"Variable","name":"0_q[(22, 16, 19)]"},"set":{"type":"LessThan","upper":1.06}},{"function":{"type":"Variable","name":"0_q[(19, 14, 16)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(6, 5, 11)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_q[(11, 9, 10)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(31, 19, 28)]"},"set":{"type":"LessThan","upper":1.0}},{"function":{"type":"Variable","name":"0_q[(9, 7, 10)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(14, 11, 18)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_q[(3, 3, 4)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_q[(29, 17, 27)]"},"set":{"type":"LessThan","upper":2.0}},{"function":{"type":"Variable","name":"0_q[(7, 6, 7)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(25, 22, 23)]"},"set":{"type":"LessThan","upper":0.33}},{"function":{"type":"Variable","name":"0_q[(4, 4, 5)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_q[(13, 9, 16)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(15, 12, 13)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(2, 2, 3)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_q[(27, 24, 25)]"},"set":{"type":"LessThan","upper":0.13}},{"function":{"type":"Variable","name":"0_q[(21, 18, 16)]"},"set":{"type":"LessThan","upper":1.0}},{"function":{"type":"Variable","name":"0_q[(26, 23, 24)]"},"set":{"type":"LessThan","upper":0.13}},{"function":{"type":"Variable","name":"0_q[(10, 8, 9)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(18, 14, 20)]"},"set":{"type":"LessThan","upper":0.47}},{"function":{"type":"Variable","name":"0_q[(5, 6, 5)]"},"set":{"type":"LessThan","upper":0.7}},{"function":{"type":"Variable","name":"0_q[(16, 14, 13)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(20, 17, 16)]"},"set":{"type":"LessThan","upper":0.25}},{"function":{"type":"Variable","name":"0_q[(12, 12, 9)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(24, 22, 21)]"},"set":{"type":"LessThan","upper":0.25}},{"function":{"type":"Variable","name":"0_q[(28, 26, 25)]"},"set":{"type":"LessThan","upper":0.13}},{"function":{"type":"Variable","name":"0_q[(8, 8, 7)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(17, 15, 14)]"},"set":{"type":"LessThan","upper":0.5}},{"function":{"type":"Variable","name":"0_q[(30, 28, 19)]"},"set":{"type":"LessThan","upper":1.0}},{"function":{"type":"Variable","name":"0_q[(1, 1, 2)]"},"set":{"type":"LessThan","upper":0.7}},{"function":{"type":"Variable","name":"0_q[(23, 21, 20)]"},"set":{"type":"LessThan","upper":0.47}},{"function":{"type":"Variable","name":"0_q[(22, 19, 16)]"},"set":{"type":"LessThan","upper":1.06}},{"function":{"type":"Variable","name":"0_q[(19, 16, 14)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(6, 11, 5)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_q[(11, 10, 9)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(31, 28, 19)]"},"set":{"type":"LessThan","upper":1.0}},{"function":{"type":"Variable","name":"0_q[(9, 10, 7)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(14, 18, 11)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_q[(3, 4, 3)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_q[(29, 27, 17)]"},"set":{"type":"LessThan","upper":2.0}},{"function":{"type":"Variable","name":"0_q[(7, 7, 6)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(25, 23, 22)]"},"set":{"type":"LessThan","upper":0.33}},{"function":{"type":"Variable","name":"0_q[(4, 5, 4)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_q[(13, 16, 9)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(15, 13, 12)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(2, 3, 2)]"},"set":{"type":"LessThan","upper":1.3}},{"function":{"type":"Variable","name":"0_q[(27, 25, 24)]"},"set":{"type":"LessThan","upper":0.13}},{"function":{"type":"Variable","name":"0_q[(21, 16, 18)]"},"set":{"type":"LessThan","upper":1.0}},{"function":{"type":"Variable","name":"0_q[(26, 24, 23)]"},"set":{"type":"LessThan","upper":0.13}},{"function":{"type":"Variable","name":"0_q[(10, 9, 8)]"},"set":{"type":"LessThan","upper":0.74}},{"function":{"type":"Variable","name":"0_q[(18, 20, 14)]"},"set":{"type":"LessThan","upper":0.47}},{"function":{"type":"Variable","name":"reservoir[1]_out"},"set":{"type":"LessThan","upper":0.1}},{"function":{"type":"Variable","name":"reservoir[2]_out"},"set":{"type":"LessThan","upper":137.99}},{"function":{"type":"Variable","name":"reservoir[3]_out"},"set":{"type":"LessThan","upper":0.042}},{"function":{"type":"Variable","name":"reservoir[4]_out"},"set":{"type":"LessThan","upper":16.76}},{"function":{"type":"Variable","name":"reservoir[5]_out"},"set":{"type":"LessThan","upper":10.35}},{"function":{"type":"Variable","name":"reservoir[6]_out"},"set":{"type":"LessThan","upper":0.32}},{"function":{"type":"Variable","name":"reservoir[7]_out"},"set":{"type":"LessThan","upper":9.72}},{"function":{"type":"Variable","name":"reservoir[8]_out"},"set":{"type":"LessThan","upper":0.07}},{"function":{"type":"Variable","name":"reservoir[9]_out"},"set":{"type":"LessThan","upper":0.04}},{"function":{"type":"Variable","name":"reservoir[10]_out"},"set":{"type":"LessThan","upper":0.0}},{"function":{"type":"Variable","name":"reservoir[11]_out"},"set":{"type":"LessThan","upper":2.93}},{"function":{"type":"Variable","name":"outflow[1]"},"set":{"type":"LessThan","upper":10.2926}},{"function":{"type":"Variable","name":"outflow[2]"},"set":{"type":"LessThan","upper":10.5531}},{"function":{"type":"Variable","name":"outflow[3]"},"set":{"type":"LessThan","upper":0.7854}},{"function":{"type":"Variable","name":"outflow[4]"},"set":{"type":"LessThan","upper":3.63}},{"function":{"type":"Variable","name":"outflow[5]"},"set":{"type":"LessThan","upper":8.74}},{"function":{"type":"Variable","name":"outflow[6]"},"set":{"type":"LessThan","upper":17.01}},{"function":{"type":"Variable","name":"outflow[7]"},"set":{"type":"LessThan","upper":1.25}},{"function":{"type":"Variable","name":"outflow[8]"},"set":{"type":"LessThan","upper":7.0}},{"function":{"type":"Variable","name":"outflow[9]"},"set":{"type":"LessThan","upper":11.0}},{"function":{"type":"Variable","name":"outflow[10]"},"set":{"type":"LessThan","upper":0.84}},{"function":{"type":"Variable","name":"outflow[11]"},"set":{"type":"LessThan","upper":3.24}}]} \ No newline at end of file diff --git a/examples/HydroPowerModels/bolivia/_demand.csv b/examples/HydroPowerModels/bolivia/_demand.csv deleted file mode 100644 index d53b74a..0000000 --- a/examples/HydroPowerModels/bolivia/_demand.csv +++ /dev/null @@ -1 +0,0 @@ -2.17019838000772,0,0,0.027549778563071,0,0,0,0,0.291517838650508,0.751049264388582,0,0.077473720490549,0.000651464621962,0,0.135214164641893,0.289427797394882,0.361466996761605,0,1.98924106313296,0.002101331952552,0,0.163010030157516,0.000651464621962,0.024354586543012,0.000651464621962,0.229624582020702 \ No newline at end of file diff --git a/examples/HydroPowerModels/bolivia/case_manifest.json b/examples/HydroPowerModels/bolivia/case_manifest.json new file mode 100644 index 0000000..9ec3c38 --- /dev/null +++ b/examples/HydroPowerModels/bolivia/case_manifest.json @@ -0,0 +1,105 @@ +{ + "case": "Bolivia (upstream case, unmodified)", + "costs": { + "active_deficit_cost_derivation": "cost_deficit 60 USD/MWh * baseMVA 100", + "active_deficit_cost_usd_per_pu_stage": 6000.0, + "reactive_balance": "hard" + }, + "demand": { + "active_load_factor": 0.6, + "deterministic": true, + "reactive_load_factor": 0.6, + "uncertainty": "none; inflow uncertainty only" + }, + "forbidden_case_files": [ + "demand.csv", + "demand_scenarios.csv", + "demand_noise.csv" + ], + "frozen_on": "2026-08-02", + "horizon": { + "lookahead_stages": 30, + "reporting_stages": 96, + "total_stages": 126 + }, + "initial_state": { + "effective": "empty (all reservoirs at zero)", + "empty_volume_tolerance": 1.0e-300, + "float32_is_exactly_zero": true, + "mechanism": "clamp(initial_volume, min_volume, max_volume) at engine precision", + "note": "Empty start. hydro.json carries denormal initial_volume values near 9e-316; both engines clamp the initial state into [min_volume, max_volume] and evaluate it at working precision, which leaves every reservoir at zero. No 70%-of-capacity repair is applied — the published result was produced from the raw bytes.", + "raw_initial_volume_max": 9.23059684e-316 + }, + "input_hashes": { + "PowerModels.json": "1ff598447957f9fc17ca570415bf5b9b5b14e1292ea3bd3163db0ad79911a782", + "hydro.json": "b25ce1c7bafcfaf907091dcd1007949c79a79974c9a33020b2587400d756b29a", + "inflows.csv": "5afb275dff3fc879e3e93b6510b81295834faad0bcd2bd1fc070a8e3e6653c77" + }, + "method": { + "sddp_backward_formulation": "SOCWRConicPowerModel", + "sddp_forward_formulation": "ACPPowerModel", + "tsddr_formulation": "ACPPowerModel", + "tsddr_target_activation": "stretchedsigmoid", + "tsddr_target_mode": "strict" + }, + "protocol": { + "indices_sha256": "ff229968f2d3b5d1ec66dc0d9f7b340785d26fa3def79f9fd9c544b6b1c9110c", + "inflow_scenarios": 15, + "rng": "StableRNG(seed); rand(1:nCen, 126, 500)", + "scenario_ids": "1:500 (global column ids; shards must preserve them)", + "scenarios": 500, + "seed": 20260706, + "stages": 126, + "uncertainty": "inflow only" + }, + "schema_version": 2, + "stage_models": { + "consumed_by": "build_hydropowermodels (JuMP/MAIN stage subproblems)", + "exports": { + "ACPPowerModel": { + "active_deficit_terms": 28, + "constraints": 884, + "hydro_balance_inflow_coefficient": 0.6048, + "hydro_balances": 11, + "matches_case_K": true, + "objective_sense": "min", + "sha256": "60d64f12efbc1c274b28e8d89c50c455aaaeaa3dc7b4208166aa8daa87079f21", + "variables": 353 + }, + "DCPPowerModel": { + "active_deficit_terms": 28, + "constraints": 391, + "hydro_balance_inflow_coefficient": 0.6048, + "hydro_balances": 11, + "matches_case_K": true, + "objective_sense": "min", + "sha256": "4fc1e35fd4b3cc0d854f63a202f8838be0e32dd925a909c6a7dea1a1c7a32fdb", + "variables": 198 + }, + "SOCWRConicPowerModel": { + "active_deficit_terms": 28, + "constraints": 1123, + "hydro_balance_inflow_coefficient": 0.6048, + "hydro_balances": 11, + "matches_case_K": true, + "objective_sense": "min", + "sha256": "531a20c6e4a7e0faffdda808d56a5a0ab0782135abc48b71f7c201a190db270f", + "variables": 385 + } + }, + "generator": "export_subproblem_mof.jl", + "note": "One-stage subproblem exports generated by export_subproblem_mof.jl from the frozen inputs through HydroPowerModels with stage_hours = 168, so the hydro-balance inflow coefficient is the case's K = 0.6048. The JuMP/MAIN workflow loads these files as its stage subproblems; SDDP builds through HydroPowerModels and the ExaModels engine builds its own model." + }, + "topology_counts": { + "branches": 31, + "buses": 28, + "generators": 34, + "hydro_units": 11, + "loads": 26 + }, + "water_balance": { + "K": 0.6048, + "K_derivation": "0.0036 * stage_hours", + "stage_hours": 168 + } +} diff --git a/examples/HydroPowerModels/eval_exa_de.jl b/examples/HydroPowerModels/eval_exa_de.jl deleted file mode 100644 index 294e564..0000000 --- a/examples/HydroPowerModels/eval_exa_de.jl +++ /dev/null @@ -1,178 +0,0 @@ -# eval_exa_de.jl -# -# Load the reference results from eval_jump_de.jl (JuMP+MadNLP/DCPPowerModel or ACPPowerModel) -# and reproduce the same problem in ExaModels+MadNLP. -# Prints a side-by-side comparison of objectives and reservoir states. -# -# Key comparison note: -# JuMP's DCPPowerModel enforces hard KCL (no load shedding variable). -# ExaModels uses a soft KCL with a deficit slack penalized at DEFICIT_COST. -# Use DEFICIT_COST >> max thermal generator cost (4244 $/pu) to match JuMP behavior. -# -# Formulation: auto-detected from reference file, or override with FORMULATION below. -# :dc — DC linearization (fast, matches DCPPowerModel reference) -# :ac_polar — Full AC polar OPF (matches ACPPowerModel reference) -# -# Usage (from this directory): -# julia --project -t auto eval_exa_de.jl - -using DecisionRulesExa -using ExaModels -using JLD2 -using MadNLP -# GPU packages (only needed when USE_GPU = true below): -using MadNLPGPU, KernelAbstractions, CUDA -using CUDSS_jll, cuDNN - -const SCRIPT_DIR = dirname(@__FILE__) -const CASE_DIR = joinpath(SCRIPT_DIR, "bolivia") -const REF_FILE = joinpath(CASE_DIR, "jump_de_reference.jld2") - -include(joinpath(SCRIPT_DIR, "hydro_power_data.jl")) -include(joinpath(SCRIPT_DIR, "hydro_power_exa.jl")) - -# ── Solve-status check (MadNLP 0.8.x) ──────────────────────────────────────── -solve_succeeded(r) = r.status == MadNLP.SOLVE_SUCCEEDED || - r.status == MadNLP.SOLVED_TO_ACCEPTABLE_LEVEL - -# ── Load reference ──────────────────────────────────────────────────────────── - -isfile(REF_FILE) || error("Reference file not found: $REF_FILE\n" * - "Run eval_jump_de.jl first (in DecisionRules.jl).") - -ref = load(REF_FILE) -obj_ref = ref["objective"] -res_ref = ref["reservoir"] # nHyd × (T+1) -x0_ref = ref["initial_state"] # length nHyd -inflows_flat = ref["inflows_flat"] # length T*nHyd, stage-major -targets_flat = ref["targets_flat"] # length T*nHyd, stage-major -max_vol_ref = ref["max_volume"] -T = ref["num_stages"] -nHyd = ref["nHyd"] -formulation = get(ref, "formulation", "DCPPowerModel") - -@info "Reference loaded: obj=$(round(obj_ref; digits=4)), T=$T, nHyd=$nHyd, formulation=$formulation" - -# ── Load ExaModels data ─────────────────────────────────────────────────────── - -const PM_FILE = joinpath(CASE_DIR, "PowerModels.json") -const HYDRO_FILE = joinpath(CASE_DIR, "hydro.json") -const INFLOW_FILE = joinpath(CASE_DIR, "inflows.csv") -const DEMAND_FILE = joinpath(CASE_DIR, "_demand.csv") - -# Load-shedding cost: must be >> max thermal generator cost (Bolivia: ~4244 $/pu) -# to ensure the solver never prefers deficit over thermal dispatch (matching -# JuMP's DCPPowerModel which has no deficit variable at all). -const DEFICIT_COST = 1e5 - -# target_penalty = :auto → ρ = 2 × max_gen_cost, matching JuMP's penalty_l2 = :auto -# (ExaModels uses (ρ/2)·δ², so ρ/2 = max_gen_cost = the same effective multiplier) -const TARGET_PEN_ARG = :auto - -# ── Detect formulation from reference ───────────────────────────────────────── -# Override here if needed: const FORMULATION = :dc or :ac_polar -const FORMULATION = if formulation == "ACPPowerModel" - @info "Detected AC formulation from reference → using :ac_polar" - :ac_polar -else - @info "Detected DC formulation from reference → using :dc" - :dc -end - -@info "Loading ExaModels power data..." -power_data = load_power_data(PM_FILE) -hydro_data = load_hydro_data(HYDRO_FILE, INFLOW_FILE, power_data; num_stages = T * 10) - -@assert hydro_data.nHyd == nHyd "nHyd mismatch: $(hydro_data.nHyd) vs $nHyd" - -demand_mat = isfile(DEMAND_FILE) ? load_demand(DEMAND_FILE, power_data; T = T) : nothing - -TARGET_PEN = auto_target_penalty(power_data, hydro_data) -@info "Auto target penalty: ρ=$(round(TARGET_PEN; digits=2)) (= 2 × max_obj_cost = 2 × $(round(TARGET_PEN/2; digits=2)))" - -@info "Building $(T)-stage ExaModels DE (formulation=$FORMULATION, deficit_cost=$DEFICIT_COST, target_penalty=:auto → $TARGET_PEN)..." -prob = build_hydro_de(power_data, hydro_data, T; - backend = CUDA.CUDABackend(), - float_type = Float64, - formulation = FORMULATION, - target_penalty = TARGET_PEN_ARG, - deficit_cost = DEFICIT_COST, - demand_matrix = demand_mat, -) - -# ── Set problem parameters (same as reference) ──────────────────────────────── - -ExaModels.set_parameter!(prob.core, prob.p_x0, x0_ref) -set_inflows!(prob, inflows_flat) -ExaModels.set_parameter!(prob.core, prob.p_target, targets_flat) - -# ── Solve ───────────────────────────────────────────────────────────────────── - -@info "Solving ExaModels DE..." -result = MadNLP.madnlp(prob.model; print_level = MadNLP.ERROR) -@info " Status: $(result.status) Objective: $(round(result.objective; digits=4))" - -solve_succeeded(result) || @warn "Solve did not fully converge ($(result.status))" - -# ── Extract solution ────────────────────────────────────────────────────────── - -sol = hydro_solution(prob, result) -res_exa = Array(sol.reservoir) # nHyd × (T+1), brought to CPU for comparison - -# ── Objective decomposition ─────────────────────────────────────────────────── -# Decompose into: generator cost + deficit cost + target penalty -# (These should sum to result.objective up to solver tolerance.) - -pg_cpu = Array(sol.pg) # bring to CPU for scalar indexing in generator loop -gen_cost = sum( - g.cost2 * pg_cpu[g_pos, t]^2 + g.cost1 * pg_cpu[g_pos, t] - for (g_pos, g) in enumerate(power_data.gens), t in 1:T -) - -def_cost_total = DEFICIT_COST * sum(sol.deficit) -tgt_pen_total = (TARGET_PEN / 2) * sum(sol.delta .^ 2) - -total_deficit_pu = sum(sol.deficit) # total active load shed (pu·stage) - -# ── Comparison table ────────────────────────────────────────────────────────── - -exa_form_str = FORMULATION === :ac_polar ? "ACPolarOPF" : "DCPPowerModel" - -println("\n" * "="^60) -println(" OBJECTIVE COMPARISON") -println("="^60) -println(" JuMP+MadNLP ($(formulation)): ", round(obj_ref; digits=4)) -println(" ExaModels+MadNLP ($(exa_form_str)): ", round(result.objective; digits=4)) -pct_diff = abs(result.objective - obj_ref) / max(abs(obj_ref), 1.0) * 100 -println(" Relative difference: ", round(pct_diff; digits=2), " %") - -println("\n" * "="^60) -println(" ExaModels OBJECTIVE BREAKDOWN") -println("="^60) -println(" Generator cost: ", round(gen_cost; digits=4)) -println(" Deficit cost: ", round(def_cost_total; digits=4), - " (total shed = ", round(total_deficit_pu; digits=6), " pu·stage)") -println(" Target penalty: ", round(tgt_pen_total; digits=4)) -println(" Sum of parts: ", round(gen_cost + def_cost_total + tgt_pen_total; digits=4)) -println(" MadNLP objective: ", round(result.objective; digits=4)) - -println("\n NOTE: Both JuMP (penalty_l2=:auto) and ExaModels (target_penalty=:auto)") -println(" use effective L2 coefficient = max_gen_cost = ", round(TARGET_PEN/2; digits=2)) -println(" ExaModels: (ρ/2)·δ² with ρ=", round(TARGET_PEN; digits=2), ". JuMP: penalty_l2·δ².") -println(" ExaModels gen cost only: ", round(gen_cost; digits=4)) - -println("\n" * "="^60) -println(" RESERVOIR STATES — end of each stage (per hydro unit)") -println("="^60) -println(" Stage: ", join(lpad.(0:T, 9))) -for r in 1:nHyd - println(" Hydro $r (ref): ", join(lpad.(round.(res_ref[r, :]; digits=1), 9))) - println(" Hydro $r (exa): ", join(lpad.(round.(res_exa[r, :]; digits=1), 9))) - max_err = maximum(abs.(res_ref[r, :] .- res_exa[r, :])) - println(" Hydro $r |err|: ", round(max_err; digits=2), "\n") -end - -total_err = maximum(abs.(res_ref .- res_exa)) -println("="^60) -println(" Max |reservoir error| across all units/stages: ", round(total_err; digits=2)) -println("="^60) diff --git a/examples/HydroPowerModels/eval_paired_exa.jl b/examples/HydroPowerModels/eval_paired_exa.jl new file mode 100644 index 0000000..224e53a --- /dev/null +++ b/examples/HydroPowerModels/eval_paired_exa.jl @@ -0,0 +1,470 @@ +#!/usr/bin/env julia + +# Paired evaluation of a trained strict TS-DDR checkpoint on the frozen Bolivia +# protocol, with the per-stage physical decisions recorded. +# +# This is the evaluator that produced the published TS-DDR distribution. It does +# NOT reimplement the rollout: it calls the production +# `DecisionRulesExa.rollout_tsddr` with the trainer's exact stage configuration +# and attaches a `stage_recorder`, which reads the solution the rollout has +# already computed. The per-column costs therefore average to the same panel mean +# the trainer's own evaluation reports for the same checkpoint. +# +# Four CSVs are always written, in the same schema as the SDDP evaluator's +# `DR_PHYSICAL_AUDIT=1` output so the two can be differenced column by column and +# stage by stage: +# +#