From 07eee9006f09d29249ba8861cba2e2b4168a043b Mon Sep 17 00:00:00 2001 From: Bennet Meyers Date: Tue, 25 Aug 2026 18:39:55 -0700 Subject: [PATCH 01/28] docs: add the August 2026 project update presentation Add the reproducible project-update deck and revise the annual-study narrative to report the S4 memory boundary and M14 time-vectorization dependency. --- .gitignore | 17 + .../weekly_update_20260826/README.md | 26 ++ .../cvxopf_project_update.tex | 362 ++++++++++++++++++ .../weekly_update_20260826/make_figures.py | 209 ++++++++++ .../weekly_update_20260826/talk_defs.tex | 44 +++ 5 files changed, 658 insertions(+) create mode 100644 presentations/weekly_update_20260826/README.md create mode 100644 presentations/weekly_update_20260826/cvxopf_project_update.tex create mode 100644 presentations/weekly_update_20260826/make_figures.py create mode 100644 presentations/weekly_update_20260826/talk_defs.tex diff --git a/.gitignore b/.gitignore index 4bd9cdd..00163da 100644 --- a/.gitignore +++ b/.gitignore @@ -277,6 +277,23 @@ experiments/dnlp_vs_pypower/*.fls experiments/dnlp_vs_pypower/*.fdb_latexmk experiments/dnlp_vs_pypower/*.synctex.gz +# Presentation outputs and LaTeX build byproducts +presentations/**/*.pdf +presentations/**/*.aux +presentations/**/*.bbl +presentations/**/*.bcf +presentations/**/*.blg +presentations/**/*.fdb_latexmk +presentations/**/*.fls +presentations/**/*.log +presentations/**/*.nav +presentations/**/*.out +presentations/**/*.run.xml +presentations/**/*.snm +presentations/**/*.synctex.gz +presentations/**/*.toc +presentations/**/*.vrb + # Local agent skills and configuration .agents/ skills-lock.json diff --git a/presentations/weekly_update_20260826/README.md b/presentations/weekly_update_20260826/README.md new file mode 100644 index 0000000..01c2a5e --- /dev/null +++ b/presentations/weekly_update_20260826/README.md @@ -0,0 +1,26 @@ +# CVXOPF project update — 2026-08-26 + +This directory contains the Beamer source for the August 26, 2026 project +meeting. Its visual structure follows the August 20 PACT weekly-update deck and +uses the accompanying `talk_defs.tex`. + +Build from this directory with: + +```sh +uv run --with matplotlib --with pandas python make_figures.py +latexmk -pdf cvxopf_project_update.tex +``` + +`make_figures.py` reconstructs presentation-specific figures from the retained +battery-terminal, M17, and Case118 experiment artifacts. The deck also uses the +curated 96-hour storage-control figure from the battery-terminal experiment. + +Generated PDFs and LaTeX build products are ignored; commit the Beamer source, +figure-generation code, and supporting source files instead. + +The deck includes the August 25 S4 annual-outer resource-boundary result: +macOS terminated the detached worker during the repeated +construction/canonicalization phase after reporting extreme compressed-memory +pressure. The Case118 annual experiment is therefore paused pending M14 +time-vectorized multistep construction; the result is not classified as OPF +infeasibility. diff --git a/presentations/weekly_update_20260826/cvxopf_project_update.tex b/presentations/weekly_update_20260826/cvxopf_project_update.tex new file mode 100644 index 0000000..7d5a3ab --- /dev/null +++ b/presentations/weekly_update_20260826/cvxopf_project_update.tex @@ -0,0 +1,362 @@ +\documentclass[aspectratio=169,11pt]{beamer} + +\definecolor{customblue}{rgb}{0.13,0.28,0.59} +\definecolor{accentorange}{rgb}{0.88,0.32,0.12} +\definecolor{mutedgreen}{rgb}{0.10,0.55,0.35} +\setbeamercolor{block title}{bg=customblue,fg=white} +\setbeamercolor{block body}{bg=customblue!8} +\setbeamercolor{alerted text}{fg=accentorange} +\setbeamertemplate{blocks}[rounded] +\usepackage{amsmath,booktabs,graphicx,tikz} +\usetikzlibrary{arrows.meta,positioning} +\input{talk_defs.tex} + +\mode{\usetheme{default}} +\usecolortheme[rgb={0.13,0.28,0.59}]{structure} +\setbeamertemplate{navigation symbols}{} +\setbeamertemplate{itemize subitem}{--} +\setbeamertemplate{footline}{% + \begin{beamercolorbox}[ht=2.5ex,dp=1.125ex,leftskip=.8cm,rightskip=.6cm]{structure} + \hfill\insertframenumber + \end{beamercolorbox}\vskip0.25cm +} + +\graphicspath{{../../experiments/}} +\newcommand{\tightitems}{\setlength{\itemsep}{0.42em}} +\newcommand{\done}{\textcolor{mutedgreen}{\textbf{Complete}}} +\newcommand{\open}{\textcolor{accentorange}{\textbf{Open}}} + +\title{CVXOPF: multiscale optimization for battery resilience} +\subtitle{From nonlinear power flow to month-scale hierarchical control} +\author{Bennet Meyers} +\date{August 26, 2026} + +\begin{document} + +\begin{frame} + \titlepage +\end{frame} + +\begin{frame}{The research goal} + \textbf{How can we plan battery energy over long horizons while respecting + the nonlinear AC network physics that determine whether each action is realizable?} + \vspace{0.7em} + \begin{columns}[T,onlytextwidth] + \column{0.48\textwidth} + \textbf{Long-horizon decisions} + \begin{itemize}\tightitems + \item energy adequacy and terminal reserves + \item renewable curtailment and load service + \item storage cycling across days to seasons + \end{itemize} + \column{0.48\textwidth} + \textbf{Short-horizon physics} + \begin{itemize}\tightitems + \item voltage and reactive-power feasibility + \item two-terminal branch ratings and losses + \item nonconvex AC solver behavior + \end{itemize} + \end{columns} + \vspace{0.4em} + \centering\large The project thesis: \textbf{plan energy globally; realize power flow locally.} +\end{frame} + +\begin{frame}{Why intertemporal optimization matters} + \begin{columns}[c,onlytextwidth] + \column{0.57\textwidth} + \includegraphics[width=\textwidth,height=0.69\textheight,keepaspectratio]{../../experiments/battery_terminal/readme_intertemporal_storage.png} + \column{0.40\textwidth} + \begin{itemize}\tightitems + \item High-stress 96-hour case9: optimal control versus two terminal-blind greedy policies. + \item The optimizer coordinates renewables, dispatch, and stored energy across four days. + \item A hard terminal policy returns the battery to 500 MWh. + \item Greedy policies exhaust or strand energy—and shed load. + \end{itemize} + \end{columns} +\end{frame} + +\begin{frame}{A common modeling system now spans the research questions} + \small + \begin{center} + \begin{tikzpicture}[scale=0.82,transform shape,node distance=6mm and 8mm, + box/.style={draw=customblue,rounded corners,fill=customblue!7,minimum height=9mm,align=center}, + arr/.style={-{Latex[length=2mm]},thick,customblue}] + \node[box] (data) {network + profiles\\\scriptsize stable device identity}; + \node[box,right=of data] (components) {component models\\\scriptsize generators, renewables, storage, loads, HVDC}; + \node[box,right=of components] (assembly) {typed assembly\\\scriptsize variables, injections, constraints, costs}; + \node[box,below=of assembly] (forms) {formulations\\\scriptsize AC, lossy DC, single-node DC}; + \node[box,left=of forms] (solve) {solve + audit\\\scriptsize stable results and residual gates}; + \node[box,left=of solve] (hier) {hierarchical control\\\scriptsize signposts, feedback, recovery}; + \draw[arr] (data)--(components); \draw[arr] (components)--(assembly); + \draw[arr] (assembly)--(forms); \draw[arr] (forms)--(solve); \draw[arr] (solve)--(hier); + \end{tikzpicture} + \end{center} + \begin{itemize} + \item Components contribute their own mathematics through a typed contract. + \item Formulation builders aggregate those contributions generically, so storage, load, and network semantics survive across layers. + \end{itemize} +\end{frame} + +\begin{frame}[shrink=5]{What the software can model today} + \small + \begin{columns}[T,onlytextwidth] + \column{0.48\textwidth} + \begin{block}{Network and formulations} + \begin{itemize}\tightitems + \item nonlinear AC OPF through CVXPY DNLP/IPOPT + \item convex lossy-DC and single-node formulations + \item active branch status and two-terminal AC thermal limits + \item sparse and dense network representations + \end{itemize} + \end{block} + \begin{block}{Intertemporal control} + \begin{itemize}\tightitems + \item single- and multistep problems + \item hard, shortfall, and soft terminal policies + \item public hierarchical DC--AC orchestration + \end{itemize} + \end{block} + \column{0.48\textwidth} + \begin{block}{First-class components} + \begin{itemize}\tightitems + \item dispatchable and nondispatchable generation + \item batteries with real/reactive capability and cycling cost + \item fixed and economically sheddable loads + \item lossy controllable HVDC links + \end{itemize} + \end{block} + \begin{block}{Research discipline} + \begin{itemize}\tightitems + \item typed identities and stable failure schemas + \item explicit objective time units + \item retained audit residuals and reproducible experiments + \end{itemize} + \end{block} + \end{columns} +\end{frame} + +\begin{frame}[shrink=3]{Equivalent mathematics can have radically different numerical behavior} + \centering + \includegraphics[width=0.98\textwidth,height=0.68\textheight,keepaspectratio]{formulation_results.pdf} + \begin{itemize}\small\tightitems + \item Direct and lifted branch-terminal equations agree below $4.5\times10^{-14}$ p.u.; paired objectives agree to solver precision. + \item Lifting adds variables and equalities but separates nonlinear voltage expressions from quadratic thermal inequalities. + \item On case57, the lifted structure was 27$\times$ faster in sparse form and 110$\times$ faster in dense form. + \end{itemize} +\end{frame} + +\begin{frame}{Terminal energy is an economic decision, not a boundary detail} + \centering + \includegraphics[width=0.98\textwidth,height=0.68\textheight,keepaspectratio]{terminal_policy_results.pdf} + \begin{itemize}\small\tightitems + \item The sampled fixed-terminal value is empirically convex and piecewise smooth. + \item Linear penalties recover a hard target beyond a marginal-value threshold; quadratic penalties create a smooth tradeoff. + \item Terminal policy therefore encodes the value or obligation attached to energy beyond the modeled horizon. + \end{itemize} +\end{frame} + +\begin{frame}{Long-horizon energy states can coordinate short-horizon AC solves} + \centering + \includegraphics[width=0.98\textwidth,height=0.68\textheight,keepaspectratio]{locality_and_handoff.pdf} + \begin{itemize}\small\tightitems + \item Terminal influence remains concentrated in a final coupled excursion as the planning horizon grows. + \item Endpoint-fixed AC subsections reach energy boundaries inherited from the long DC solution while choosing their own network-feasible trajectories. + \end{itemize} +\end{frame} + +\begin{frame}{The hierarchical controller closes the loop} + \centering + \begin{tikzpicture}[node distance=8mm and 12mm, + box/.style={draw=customblue,rounded corners,fill=customblue!7,minimum width=31mm,minimum height=13mm,align=center}, + arr/.style={-{Latex[length=2.5mm]},very thick,customblue}] + \node[box] (outer) {long-horizon DC\\\scriptsize feasible SoC signposts}; + \node[box,right=of outer] (window) {short AC window\\\scriptsize hard/soft endpoint}; + \node[box,right=of window] (action) {accept first action\\\scriptsize audited AC dispatch}; + \node[box,below=of window] (state) {realized state feedback\\\scriptsize SoC + causal warm start}; + \draw[arr] (outer)--(window); \draw[arr] (window)--(action); + \draw[arr] (action)|-(state); \draw[arr] (state)-|(outer); + \end{tikzpicture} + \vspace{1em} + \begin{itemize}\tightitems + \item The outer model maintains the energy plan; the inner model realizes the next action with AC voltage, reactive-power, loss, and thermal physics. + \item Realized state—not an imagined DC action—feeds the next decision. + \end{itemize} +\end{frame} + +\begin{frame}{The first 96-hour study exposed two different failure mechanisms} + \centering + \includegraphics[width=0.92\textwidth,height=0.55\textheight,keepaspectratio]{m17_policy_outcomes.pdf} + \begin{itemize}\tightitems + \item \textbf{Numerical/local-solver sensitivity:} flat-start IPOPT reported infeasible at one hard-target window; six alternate starts solved the identical problem. + \item \textbf{Genuine loss of terminal viability:} soft deviations left 128.1 MW required charging in the last hour, but only 123.6 MW aggregate headroom. + \end{itemize} +\end{frame} + +\begin{frame}{Causal initialization recovery works in the reference scenario} + \begin{columns}[T,onlytextwidth] + \column{0.58\textwidth} + \textbf{Frozen 96-hour recovery experiment} + \begin{itemize}\tightitems + \item 96/96 intervals completed with hard AC endpoints. + \item Shifted preceding AC solution succeeded on 94/95 later windows (98.9\%). + \item The one failed audit recovered through a target-free solve followed by a copied hard-target solve. + \item 98 AC solves total; no perturbation attempts needed. + \end{itemize} + \column{0.38\textwidth} + \textbf{Interpretation} + \begin{itemize}\tightitems + \item Warm starts are part of the operational method, not merely a speed hint. + \item A local solver status is not a physical infeasibility certificate. + \item M17 subsequently matched the frozen manual reference across all four policy cases with zero failed comparisons. + \end{itemize} + \end{columns} +\end{frame} + +\begin{frame}{Case118 makes the computational boundary visible} + \begin{columns}[T,onlytextwidth] + \column{0.54\textwidth} + \textbf{Six-hour rated AC pilot} + \begin{itemize}\tightitems + \item 205.9 MW maximum storage movement + \item 465.8 MWh battery throughput + \item thermally binding accepted solution + \item 34.5 minute solve + \item 14.66 GiB peak process RSS + \end{itemize} + \column{0.42\textwidth} + \begin{itemize}\tightitems + \item \textbf{Scientifically,} the battery is active and network-constrained—not an inert device in a large network. + \item \textbf{Computationally,} direct 24-hour or annual AC optimization is not a responsible baseline on this stack. + \end{itemize} + \end{columns} +\end{frame} + +\begin{frame}{The hierarchy has progressed from hours to a month} + \small + \begin{center} + \begin{tikzpicture}[scale=0.80,transform shape,node distance=5mm, + stage/.style={draw=customblue,rounded corners,minimum width=25mm,minimum height=13mm,align=center,fill=customblue!7}, + arr/.style={-{Latex[length=2mm]},thick,customblue}] + \node[stage] (pilot) {6 hours\\\scriptsize AC scaling boundary}; + \node[stage,right=of pilot] (day) {24 hours\\\scriptsize outer + endpoint}; + \node[stage,right=of day] (week) {168 hours\\\scriptsize complete with restart}; + \node[stage,right=of week] (month) {720 hours\\\scriptsize complete, 44 recycles}; + \node[stage,right=of month,fill=accentorange!12,draw=accentorange] (year) {8,760 hours\\\scriptsize time-vectorization boundary}; + \draw[arr] (pilot)--(day); \draw[arr] (day)--(week); \draw[arr] (week)--(month); \draw[arr] (month)--(year); + \end{tikzpicture} + \end{center} + \vspace{0.8em} + \begin{itemize}\tightitems + \item Week: 168/168 accepted intervals; the 16 GiB supervisor stopped safely at 128 and a fresh continuation completed the trajectory. + \item Month: 720/720 accepted intervals; three copied-target-free recoveries; maximum external RSS 15.99 GiB. + \item Tail latency: a predeclared 300-second primary budget plus causal recovery reduced latency on all three observed slow-success windows. + \end{itemize} +\end{frame} + +\begin{frame}{Process recycling controls memory without changing the science} + \centering + \includegraphics[width=0.98\textwidth,height=0.69\textheight,keepaspectratio]{recycling_memory.pdf} + \begin{itemize}\small\tightitems + \item All three 64-interval arms completed with identical causal trajectories. + \item Peak external RSS fell from 20.03 GiB (never) to 17.93 GiB (recycle every 16). + \item Fresh-process execution is now an explicit part of the scalable experimental method. + \end{itemize} +\end{frame} + +\begin{frame}{The annual study separates planning, partitioning, and execution} + \centering + \begin{tikzpicture}[scale=0.88,transform shape,node distance=7mm and 10mm, + box/.style={draw=customblue,rounded corners,fill=customblue!7,minimum width=30mm,minimum height=13mm,align=center}, + arr/.style={-{Latex[length=2.5mm]},very thick,customblue}] + \node[box] (dc) {annual lossy-DC solve\\\scriptsize 8,760-hour SoC signposts}; + \node[box,right=of dc] (cut) {select shard boundaries\\\scriptsize near mid-SoC charging opportunities}; + \node[box,right=of cut] (ac) {independent AC shards\\\scriptsize fresh workers / HPC nodes}; + \node[box,below=of cut] (merge) {deterministic merge + audit\\\scriptsize continuity, identity, residuals}; + \draw[arr] (dc)--(cut); \draw[arr] (cut)--(ac); \draw[arr] (ac)|-(merge); \draw[arr] (merge)-|(dc); + \end{tikzpicture} + \vspace{1em} + \begin{itemize}\tightitems + \item The supervised annual outer-only S4 gate is implemented, reviewed, and committed—but the existing per-step CVXPY graph did not fit the machine. + \item macOS killed the detached worker at the same late construction/canonicalization phase: sampled RSS was 11.69 GiB, while the kernel reported 198,602 MB for the largest compressed process. + \item The experiment is paused for M14 time vectorization; an accepted outer trajectory will still determine—not be tuned by—the later sharding qualification. + \end{itemize} +\end{frame} + +\begin{frame}{Annual failure identifies the next milestone} + \begin{columns}[T,onlytextwidth] + \column{0.50\textwidth} + \textbf{What the failed workers established} + \begin{itemize}\tightitems + \item No outer primal or annual signpost artifact was produced. + \item The experiment supervisor triggered neither its 16 GiB RSS limit nor its wall-time limits. + \item A launchd-owned retry ruled out the Codex command resource group and presentation edits. + \item The event is a construction/canonicalization resource boundary—not infeasibility. + \end{itemize} + \column{0.46\textwidth} + \textbf{M14: vectorize time} + \begin{itemize}\tightitems + \item time-indexed matrix variables + \item batched network/component constraints + \item sparse storage-difference operators + \item vectorized costs and reporting + \item short-horizon equivalence before annual rerun + \end{itemize} + \end{columns} +\end{frame} + +\begin{frame}{What we have learned} + \begin{enumerate}\tightitems + \item \textbf{Model structure matters computationally.} Equivalent nonlinear formulations can differ by orders of magnitude in tractability. + \item \textbf{Terminal energy is part of the scientific model.} Hard obligations, reserve floors, and soft value functions answer different questions. + \item \textbf{DC signposts can coordinate AC realizations.} The layers need shared state, not identical trajectories. + \item \textbf{Feedback is not recursive feasibility.} Soft deviations can consume the remaining ability to satisfy a terminal obligation. + \item \textbf{Solver recovery is operationally relevant.} Causal warm starts distinguish numerical failure from demonstrated physical infeasibility. + \item \textbf{Scaling requires both algebra and systems engineering.} Time-vectorized graphs, supervision, immutable artifacts, recycling, and sharding are part of doing the science correctly. + \end{enumerate} +\end{frame} + +\begin{frame}{Next steps} + \begin{columns}[T,onlytextwidth] + \column{0.48\textwidth} + \textbf{Immediate Case118 path} + \begin{enumerate}\tightitems + \item complete M14 lossy-DC time vectorization + \item rerun and analyze annual outer S4 + \item freeze and qualify shard boundaries + \item run and merge the annual AC hierarchy + \end{enumerate} + \column{0.48\textwidth} + \textbf{Research extensions} + \begin{itemize}\tightitems + \item recursive-feasibility protection with load shedding + \item configurable multi-layer hierarchies + \item SOCP as a possible middle layer + \item uncertainty, contingencies, and storage siting/sizing + \item reactive-support selection and pricing questions + \end{itemize} + \end{columns} +\end{frame} + +\appendix + +\begin{frame}{Appendix: load shedding is now a first-class reliability decision} + \begin{itemize}\tightitems + \item Loads have stable identities, fixed active/reactive demand, optional shedding eligibility, fractional caps, and VOLL-like costs. + \item The model reports served load, shed load, fraction shed, energy not served, and integrated shedding cost. + \item In the controlled single-node case, shedding below the relevant generator marginal cost and full service above it produce the expected economic phase transition. + \item Explicit time-varying inequalities and leaf-bound representations agreed to solver precision; explicit inequalities were retained for clarity and uniformity. + \end{itemize} +\end{frame} + +\begin{frame}{Appendix: scientific boundaries} + \small + \begin{itemize}\tightitems + \item AC results are accepted local solutions from CVXPY DNLP/IPOPT, not global-optimality certificates. + \item Results establish behavior for the frozen case9/Tracy and synthetic Case118 scenarios; they are not universal reliability claims. + \item The current lossy-DC formulation penalizes a resistance proxy but retains lossless nodal conservation; AC provides the physical-loss realization. + \item The reactive-support tie-breaker is a planned experiment, not a completed result. + \item The historical DNLP/Pypower HVDC cross-evaluation needs reconciliation with the current post-branch-limit implementation before reuse as a headline result. + \end{itemize} +\end{frame} + +\end{document} diff --git a/presentations/weekly_update_20260826/make_figures.py b/presentations/weekly_update_20260826/make_figures.py new file mode 100644 index 0000000..d43de0a --- /dev/null +++ b/presentations/weekly_update_20260826/make_figures.py @@ -0,0 +1,209 @@ +"""Generate presentation figures from retained cvxopf experiment artifacts.""" + +from __future__ import annotations + +import json +from pathlib import Path + +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd + + +ROOT = Path(__file__).resolve().parents[2] +HERE = Path(__file__).resolve().parent +BATTERY = ROOT / "experiments/battery_terminal/results" +M17 = ( + ROOT + / "experiments/hierarchical_battery_resilience/results/s3_authoritative_0cd65b1" +) +CASE118 = ROOT / "experiments/case118_annual_hierarchy" + +BLUE = "#214796" +ORANGE = "#e0521f" +GREEN = "#198c59" +GRAY = "#777777" + + +def finish(fig: plt.Figure, name: str) -> None: + fig.tight_layout() + fig.savefig(HERE / name, bbox_inches="tight") + plt.close(fig) + + +def terminal_value() -> None: + data = pd.read_csv(BATTERY / "terminal_value_sweep.csv") + fig, axes = plt.subplots(1, 2, figsize=(10.8, 4.0)) + for scenario, group in data.groupby("scenario", sort=False): + group = group[group["status"].isin(("optimal", "optimal_inaccurate"))] + operating = group["objective"] - group["objective"].min() + axes[0].plot(group["target_mwh"], operating, marker="o", ms=3, label=scenario) + axes[0].set( + xlabel="Required terminal SoC (MWh)", ylabel="Incremental operating cost" + ) + axes[0].set_title("Terminal energy has a convex operating value", fontweight="bold") + axes[0].grid(alpha=0.25) + axes[0].legend(frameon=False) + + soft = pd.read_csv(BATTERY / "soft_weight_sweep.csv") + high = soft[soft["scenario"] == "high"] + for kind, group in high.groupby("cost_kind", sort=False): + axes[1].semilogx( + group["weight"], group["terminal_soc_mwh"], marker="o", ms=4, label=kind + ) + axes[1].axhline(500, color=ORANGE, linestyle="--", label="500 MWh target") + axes[1].set(xlabel="Terminal penalty weight", ylabel="Optimized terminal SoC (MWh)") + axes[1].set_title( + "Linear penalties become exact; quadratic penalties approach", fontweight="bold" + ) + axes[1].grid(alpha=0.25) + axes[1].legend(frameon=False) + finish(fig, "terminal_policy_results.pdf") + + +def locality_and_handoff() -> None: + horizon = pd.read_csv(BATTERY / "horizon_study.csv") + horizon = horizon[horizon["policy"].isin(("equality", "quadratic"))] + fig, axes = plt.subplots(1, 2, figsize=(10.8, 4.0)) + styles = {"equality": "-", "quadratic": "--"} + for (scenario, policy), group in horizon.groupby( + ["scenario", "policy"], sort=False + ): + axes[0].plot( + group["horizon_steps"], + 100 * group["final_excursion_fraction"], + linestyle=styles[policy], + marker="o", + ms=3, + label=f"{scenario}, {policy}", + ) + axes[0].set( + xlabel="Horizon (hours)", ylabel="Policy-sensitive suffix (% of horizon)" + ) + axes[0].set_title( + "Terminal influence becomes local in long horizons", fontweight="bold" + ) + axes[0].grid(alpha=0.25) + axes[0].legend(frameon=False, fontsize=8) + + traces = pd.read_csv(BATTERY / "subset_trajectories.csv") + traces = traces[ + (traces["case"] == "crosses_boundary") & (traces["battery_index"] == 0) + ] + for formulation, group in traces.groupby("formulation", sort=False): + axes[1].plot( + group["global_post_step_state"], + group["soc_mwh"], + marker="o", + label=formulation, + ) + axes[1].axhline(1000, color=ORANGE, linestyle="--", label="battery capacity") + axes[1].set(xlabel="Global boundary", ylabel="Battery SoC (MWh)") + axes[1].set_title( + "Short AC realization preserves the DC energy boundary", fontweight="bold" + ) + axes[1].grid(alpha=0.25) + axes[1].legend(frameon=False) + finish(fig, "locality_and_handoff.pdf") + + +def formulation_results() -> None: + fig, axes = plt.subplots( + 1, 2, figsize=(10.8, 4.0), gridspec_kw={"width_ratios": [1.15, 1]} + ) + cases = ["case9\nsparse", "case57\nsparse", "case9\ndense", "case57\ndense"] + ratios = [3.2, 27.2, 4.0, 110.1] + bars = axes[0].bar(cases, ratios, color=[GREEN, GREEN, ORANGE, ORANGE]) + axes[0].bar_label(bars, fmt="%.1f×", padding=3) + axes[0].set_yscale("log") + axes[0].set_ylabel("Direct / lifted solve time") + axes[0].set_title( + "Equivalent lifted branch limits solve much faster", fontweight="bold" + ) + axes[0].grid(axis="y", alpha=0.25) + + metrics = ["variables", "equalities", "inequalities"] + direct = [668, 655, 188] + lifted = [988, 975, 188] + x = np.arange(3) + width = 0.36 + axes[1].bar(x - width / 2, direct, width, label="direct", color=GRAY) + axes[1].bar(x + width / 2, lifted, width, label="lifted", color=BLUE) + axes[1].set_xticks(x, metrics) + axes[1].set_ylabel("Scalar model entries (case57 sparse)") + axes[1].set_title( + "The faster representation is algebraically larger", fontweight="bold" + ) + axes[1].legend(frameon=False) + axes[1].grid(axis="y", alpha=0.25) + finish(fig, "formulation_results.pdf") + + +def m17_outcomes() -> None: + data = pd.read_csv(M17 / "trajectory_summary.csv") + labels = ["frozen / hard", "frozen / soft", "replanned / hard", "replanned / soft"] + colors = [GREEN, BLUE, ORANGE, ORANGE] + fig, ax = plt.subplots(figsize=(9.8, 3.8)) + bars = ax.barh(labels, data["completed_intervals"], color=colors) + ax.axvline(96, color="black", linewidth=1) + for bar, completed in zip(bars, data["completed"], strict=True): + text = "complete" if completed else "stopped" + ax.text( + bar.get_width() + 1, bar.get_y() + bar.get_height() / 2, text, va="center" + ) + ax.set(xlim=(0, 108), xlabel="Accepted executed intervals (of 96)") + ax.set_title( + "Hard obligations complete; soft deviation can lose terminal viability", + fontweight="bold", + ) + ax.grid(axis="x", alpha=0.25) + ax.invert_yaxis() + finish(fig, "m17_policy_outcomes.pdf") + + +def recycling() -> None: + data = json.loads((CASE118 / "RECYCLE_COMPARISON_RESULTS.json").read_text()) + fig, ax = plt.subplots(figsize=(10.2, 4.0)) + names = { + "never": "never recycle", + "recycle_32": "every 32 intervals", + "recycle_16": "every 16 intervals", + } + colors = {"never": ORANGE, "recycle_32": BLUE, "recycle_16": GREEN} + for arm in ("never", "recycle_32", "recycle_16"): + series = data["arms"][arm]["after_release_series"] + ax.plot( + [p["iteration"] for p in series], + [p["rss_mib"] / 1024 for p in series], + marker=".", + linewidth=1.5, + label=names[arm], + color=colors[arm], + ) + for boundary in (16, 32, 48): + ax.axvline(boundary, color="#cccccc", linewidth=0.8, zorder=0) + ax.set( + xlabel="Completed AC interval", ylabel="Worker RSS after model release (GiB)" + ) + ax.set_title( + "Fresh workers bound process-lifetime memory while preserving the trajectory", + fontweight="bold", + ) + ax.grid(alpha=0.2) + ax.legend(frameon=False, ncols=3, loc="lower center") + finish(fig, "recycling_memory.pdf") + + +def main() -> None: + plt.rcParams.update( + {"font.size": 10, "axes.spines.top": False, "axes.spines.right": False} + ) + terminal_value() + locality_and_handoff() + formulation_results() + m17_outcomes() + recycling() + + +if __name__ == "__main__": + main() diff --git a/presentations/weekly_update_20260826/talk_defs.tex b/presentations/weekly_update_20260826/talk_defs.tex new file mode 100644 index 0000000..7fa9d85 --- /dev/null +++ b/presentations/weekly_update_20260826/talk_defs.tex @@ -0,0 +1,44 @@ +% Traditional presentation definitions shared with the update-slide template. +\newcommand{\BEAS}{\begin{eqnarray*}} +\newcommand{\EEAS}{\end{eqnarray*}} +\newcommand{\BEA}{\begin{eqnarray}} +\newcommand{\EEA}{\end{eqnarray}} +\newcommand{\BEQ}{\begin{equation}} +\newcommand{\EEQ}{\end{equation}} +\newcommand{\BIT}{\begin{itemize}} +\newcommand{\EIT}{\end{itemize}} +\newcommand{\BNUM}{\begin{enumerate}} +\newcommand{\ENUM}{\end{enumerate}} +\newcommand{\BF}{\begin{frame}} +\newcommand{\EF}{\end{frame}} + +\newcommand{\argmin}{\mathop{\rm argmin}} +\newcommand{\sign}{\mathop{\rm sign}} + +\newcommand{\cf}{{\it cf.}} +\newcommand{\eg}{{\it e.g.}} +\newcommand{\ie}{{\it i.e.}} +\newcommand{\etc}{{\it etc.}} + +\newcommand{\ones}{\mathbf 1} + +\newcommand{\reals}{{\mbox{\bf R}}} +\newcommand{\integers}{{\mbox{\bf Z}}} +\newcommand{\complex}{{\mbox{\bf C}}} +\newcommand{\symm}{{\mbox{\bf S}}} + +\newcommand{\Span}{\mbox{\textrm{span}}} +\newcommand{\Range}{\mbox{\textrm{range}}} +\newcommand{\nullspace}{{\mathcal N}} +\newcommand{\range}{{\mathcal R}} +\newcommand{\Nullspace}{\mbox{\textrm{nullspace}}} +\newcommand{\Rank}{\mathop{\bf Rank}} +\newcommand{\Card}{\mathop{\bf Card}} +\newcommand{\Tr}{\mathop{\bf Tr}} +\newcommand{\diag}{\mathop{\bf diag}} +\newcommand{\lambdamax}{{\lambda_{\rm max}}} +\newcommand{\lambdamin}{\lambda_{\rm min}} + +\newcommand{\Expect}{\mathop{\bf E{}}} +\newcommand{\Prob}{\mathop{\bf Prob}} +\newcommand{\erf}{\mathop{\bf erf}} From ad1a40dbdd786fd19ab3755b7a754ae46207eb48 Mon Sep 17 00:00:00 2001 From: Bennet Meyers Date: Tue, 25 Aug 2026 18:43:22 -0700 Subject: [PATCH 02/28] docs: define the M14 time-vectorization milestone Promote time-axis vectorization to the next blocking milestone, preserve formulation and result compatibility gates, and define the lossy-DC annual resumption boundary. --- CLAUDE.md | 2 +- README.md | 6 +- .../case118_annual_hierarchy/.gitignore | 1 + plans/milestone-14-time-vectorization.md | 176 ++++++++++++++++++ 4 files changed, 183 insertions(+), 2 deletions(-) create mode 100644 experiments/case118_annual_hierarchy/.gitignore create mode 100644 plans/milestone-14-time-vectorization.md diff --git a/CLAUDE.md b/CLAUDE.md index af2ba9e..6c7376e 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -726,7 +726,7 @@ is present. | 11 — SOCP (convex) network model | 🔲 Future | | | 12 — Extend battery parameters: final SoC, penalty vs constraint | ✅ Complete | Storage-owned terminal equality or zero-shortfall constraints and linear/quadratic, one-/two-sided terminal costs, consistently composed across formulations. See `plans/milestone-12-storage-terminal-soc.md`. | | 13 — Implement cvxpy parameters for problem data | 🔲 Future | Faster resolves of same problem over new data | -| 14 — Vectorize time constraints | 🔲 Future | currently built with iterative loop | +| 14 — Time-vectorized multistep formulations | 🟧 Next / blocking | Replace per-step CVXPY expression graphs with time-indexed matrix expressions and sparse temporal operators while preserving formulation, failure, audit, and result contracts. Vectorized lossy DC is the first delivery and blocks resumption of the Case118 annual S4 outer solve after macOS killed the repeated annual graph under extreme compressed-memory pressure. See `plans/milestone-14-time-vectorization.md`. | | 15 — Full lossy HVDC (sign-switching converter losses) | 🔲 Future | charge/discharge-style split of `p_in`; adds fixed converter loss (`LOSS0`); enables losses in `free` and zero-straddling `band` steps; reactive-power support proposed. See `plans/milestone-15-full-lossy-hvdc.md`. | | 16 — Unify grid component model patterns | ✅ Complete | Generators, storage, nondispatchable units, and HVDC share formulation-specific injection and operating-set APIs, temporal coupling slots, and device-owned cost boundaries. Includes first-class `DispatchableGenerator`, MATPOWER fallback, stable identity for external ND/HVDC tables, and collapsed singlenode reuse. See `plans/milestone-16-unify-components.md` and `memories/M16-in-flight-record.md`. | | 17 — Hierarchical DC→AC receding-horizon dispatch | ✅ Complete | The capstone controller passes **identity-aligned SoC signposts only** (not other setpoints) from long-horizon `lossy_dc` planning into short AC-OPF windows, executes only residual-checked target-conditioned first actions, supports causal shifted initialization with audited recovery, and retains the complete plan/attempt tree. M17 fixes the validated `lossy_dc`→`ac` workflow; configurable formulations and additional layers are M21. See `plans/milestone-17-hierarchical-dc-ac.md`. | diff --git a/README.md b/README.md index 9535d68..c1a0b8b 100644 --- a/README.md +++ b/README.md @@ -794,7 +794,11 @@ package environment. - [ ] SOCP network model - [x] Extend battery parameters: terminal equality/shortfall constraints and linear/quadratic terminal costs - [ ] Implement cvxpy parameters for problem data -- [ ] Vectorize time constraints (currently built with iterative loop) +- [ ] M14 time-vectorized multistep formulations: replace per-step CVXPY + construction with time-indexed matrix expressions and sparse temporal + operators while preserving formulation and result equivalence. This is the + current scaling priority and blocks resumption of the Case118 annual S4 outer + solve (see `plans/milestone-14-time-vectorization.md`). - [ ] Full lossy HVDC (sign-switching converter losses via charge/discharge split) and reactive power support - [x] Unify grid component model patterns (dispatchable generators, storage, nondispatchable → first-class composable components) - [x] M16+ typed component adapters and shared formulation assembly (see `plans/milestone-16-plus-component-adapters.md`) diff --git a/experiments/case118_annual_hierarchy/.gitignore b/experiments/case118_annual_hierarchy/.gitignore new file mode 100644 index 0000000..fbca225 --- /dev/null +++ b/experiments/case118_annual_hierarchy/.gitignore @@ -0,0 +1 @@ +results/ diff --git a/plans/milestone-14-time-vectorization.md b/plans/milestone-14-time-vectorization.md new file mode 100644 index 0000000..6a8c62a --- /dev/null +++ b/plans/milestone-14-time-vectorization.md @@ -0,0 +1,176 @@ +# Milestone 14 — Time-vectorized multistep formulations + +## Status + +**Required next milestone.** The Case118 annual hierarchy experiment is paused +at S4 until the annual lossy-DC outer problem passes the M14 construction, +canonicalization, solve, equivalence, and resource gates below. + +## Motivation + +`build_opf_multistep()` currently constructs one collection of CVXPY variables, +constraints, injections, and cost expressions per time step. This preserves a +clear single-step component contract, but the Python object graph and CVXPY +canonicalization graph grow poorly with horizon length. + +The Case118 S4 annual outer experiment made that limitation observable. Three +annual workers reached the same late construction/canonicalization phase +and received `SIGKILL` after roughly 8.5 minutes. The detached attempt ruled out +the Codex command resource group: macOS recorded + +```text +memorystatus: killing largest compressed process python3.11 [...] 198602 MB +``` + +while the experiment supervisor had sampled a peak resident set of 11,973 MiB +and had triggered neither its 16 GiB RSS limit nor its wall-time limits. The +machine has 36 GiB of physical memory. Repeating the same per-step expression +graph with a larger supervisor allowance is therefore not a credible annual +execution strategy. + +M14 replaces repeated time-step expression construction with time-indexed +matrix expressions and sparse temporal operators while preserving the +scientific formulation and public result contract. + +## Scientific and compatibility boundary + +Time vectorization is an implementation transformation. It must not silently +change: + +- engineering units, signs, device identities, or row ordering; +- the feasible set, objective terms, or terminal-policy semantics; +- branch-rating treatment, loss proxy, or nodal conservation; +- storage recurrence, initial state, or terminal state; +- unsuccessful-solve classification and retained input metadata; +- single-step behavior or intentional multistep `T=1` behavior; +- extracted result keys, values, shapes, or time ordering; or +- the accepted M17 hierarchy and audit rules. + +Numerical agreement is evaluated using predeclared absolute and normalized +residual tolerances appropriate to each quantity. Solver trajectories and raw +floating-point serialization are not required to be byte-identical. + +## Scope and sequence + +### M14a — Freeze the baseline + +Before changing construction: + +1. Characterize the existing variable, constraint, parameter, expression, + result, and failure schemas for all three formulations. +2. Record scalar-variable, equality, inequality, and cone dimensions for + representative component combinations and horizons. +3. Retain matched short-horizon objective, trajectory, and residual fixtures. +4. Measure construction, canonicalization, solve, extraction, peak RSS, and + artifact size over an increasing horizon ladder. +5. Preserve the failed S4 attempts as resource-boundary evidence; do not + reinterpret them as solver infeasibility. + +### M14b — Vectorized horizon assembly contract + +Introduce an internal horizon-level assembly path with: + +- variables whose leading dimension is time; +- batched component injections, operating sets, and stage costs; +- sparse difference/selection operators for temporal coupling; +- vectorized integration of stage costs and reported component costs; +- stable device axes and explicit time axes; and +- a deliberate compatibility adapter for the existing public + `OPFBuild.variables`, expressions, and extraction contracts. + +The compatibility adapter must be designed and tested explicitly. It must not +materialize thousands of new CVXPY objects merely to recreate the old internal +list representation. If an internal/public representation must change, freeze +that change through a separately reviewed typed contract before implementation. + +### M14c — Vectorized lossy DC + +Implement the annual-experiment blocker first: + +- time-by-branch flow variables; +- batched nodal active-power balance; +- batched branch limits and resistance-weighted loss proxy; +- vectorized dispatchable-generation costs and bounds; +- vectorized fixed/sheddable load channels; +- vectorized nondispatchable availability and curtailment reporting; +- vectorized storage power, SoC recurrence, cycling cost, and terminal policy; +- vectorized HVDC boxes, injections, costs, and supported loss semantics; and +- exact preservation of the lossy-DC audit and result schema. + +The implementation should use sparse linear operators where they materially +reduce graph size. Replacing a left-deep Python sum with a balanced sum is a +useful local correction but does not, by itself, complete this stage. + +### M14d — Single-node DC and AC + +Apply the same horizon contract to single-node DC and AC after the lossy-DC +path is stable. AC requires an additional design gate because IPOPT starting +coordinates, original-variable names, canonicalization-added coordinates, and +the M17 causal initialization audit are part of the accepted public contract. + +Annual S4 may resume after M14c passes its gates; it does not need to wait for +AC time vectorization. M14 as a repository milestone is complete only after +the declared single-node and AC scope also passes, or after a reviewed plan +revision explicitly narrows that scope. + +## Verification ladder + +For each implemented formulation: + +1. **Structural unit tests:** dimensions, axes, identities, bounds, and sparse + temporal operators. +2. **`T=1` tests:** intentional multistep results agree with the existing + single-step formulation while retaining multistep shapes. +3. **Short-horizon equivalence:** old and vectorized builders agree on + objectives, results, component costs, and independent residual audits. +4. **Failure equivalence:** infeasible, solver-failure, and unusable-primal + records preserve their stable schemas and classifications. +5. **Component matrix:** generators, storage, loads/shedding, + nondispatchable generation, and conditional HVDC paths. +6. **Scaling ladder:** increasing Case118 horizons through 24, 168, 720, and + 8,760 steps, stopping safely at predeclared resource boundaries. +7. **Hierarchy regression:** M17 focused tests and the retained S7 equivalence + gate remain clean. + +Strict mypy, Ruff, the complete test suite, and `git diff --check` remain +required repository gates. + +## Annual S4 resumption gate + +The Case118 `big-experiment` branch remains on hold until all of the following +are true: + +1. the exact frozen S4 annual inputs build through the vectorized lossy-DC + path; +2. the 24-hour public-versus-streaming outer equivalence gate passes; +3. the vectorized annual model retains the expected formulation identity, + dimensions, storage identities, terminal target, and provenance hashes; +4. construction, canonicalization, and solve remain within a newly reviewed + memory and wall-time envelope; +5. no OS memory-pressure termination occurs; +6. the independently reconstructed outer audit is accepted; and +7. execution occurs from a clean committed source with a fresh output + directory. + +The new annual result must identify the vectorized execution commit. It is not +a continuation of any failed S4 worker. + +## Non-goals + +M14 does not: + +- weaken the annual experiment or M17 acceptance gates; +- introduce approximate temporal aggregation; +- change the one-hour S4 time resolution; +- claim that vectorization alone makes direct annual AC OPF practical; +- redesign the hierarchy or shard policy; +- add uncertainty, contingencies, or alternative storage physics; or +- erase the scientific value of the observed memory boundary. + +## Completion criteria + +M14 is complete when the reviewed vectorized paths preserve the frozen +mathematics and result contracts, pass the verification ladder, and demonstrate +materially improved time-axis construction/canonicalization scaling. M14c is +complete—and S4 may resume—when the exact 8,760-step Case118 lossy-DC outer +problem clears the annual resumption gate. From dfc7bf3ad167db84016c50623884c51aa656683e Mon Sep 17 00:00:00 2001 From: Bennet Meyers Date: Tue, 25 Aug 2026 20:53:03 -0700 Subject: [PATCH 03/28] docs: refine M14 vectorization and equivalence protocol Expand the M14 plan around permanent stepwise/CPP and vectorized/SCIPY assembly modes, time-last tensor semantics, static-data broadcasting, formulation-specific leaf-bound qualification, and scaling gates. Define representation-aware and nonunique-optimum equivalence, and allow the first accepted annual run to serve as both the M14 qualification and authoritative S4 result. --- CLAUDE.md | 2 +- README.md | 10 +- plans/milestone-14-time-vectorization.md | 351 +++++++++++++++++++++-- 3 files changed, 332 insertions(+), 31 deletions(-) diff --git a/CLAUDE.md b/CLAUDE.md index 6c7376e..93700c1 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -726,7 +726,7 @@ is present. | 11 — SOCP (convex) network model | 🔲 Future | | | 12 — Extend battery parameters: final SoC, penalty vs constraint | ✅ Complete | Storage-owned terminal equality or zero-shortfall constraints and linear/quadratic, one-/two-sided terminal costs, consistently composed across formulations. See `plans/milestone-12-storage-terminal-soc.md`. | | 13 — Implement cvxpy parameters for problem data | 🔲 Future | Faster resolves of same problem over new data | -| 14 — Time-vectorized multistep formulations | 🟧 Next / blocking | Replace per-step CVXPY expression graphs with time-indexed matrix expressions and sparse temporal operators while preserving formulation, failure, audit, and result contracts. Vectorized lossy DC is the first delivery and blocks resumption of the Case118 annual S4 outer solve after macOS killed the repeated annual graph under extreme compressed-memory pressure. See `plans/milestone-14-time-vectorization.md`. | +| 14 — Time-vectorized multistep formulations | 🟧 Next / blocking | Add an explicit time-last tensor assembly mode using SCIPY canonicalization alongside the retained stepwise/CPP path, preserving formulation, failure, audit, and result contracts while enabling direct profiling of both temporal representations. Vectorized lossy DC is the first delivery and blocks resumption of the Case118 annual S4 outer solve after macOS killed the repeated annual graph under extreme compressed-memory pressure. See `plans/milestone-14-time-vectorization.md`. | | 15 — Full lossy HVDC (sign-switching converter losses) | 🔲 Future | charge/discharge-style split of `p_in`; adds fixed converter loss (`LOSS0`); enables losses in `free` and zero-straddling `band` steps; reactive-power support proposed. See `plans/milestone-15-full-lossy-hvdc.md`. | | 16 — Unify grid component model patterns | ✅ Complete | Generators, storage, nondispatchable units, and HVDC share formulation-specific injection and operating-set APIs, temporal coupling slots, and device-owned cost boundaries. Includes first-class `DispatchableGenerator`, MATPOWER fallback, stable identity for external ND/HVDC tables, and collapsed singlenode reuse. See `plans/milestone-16-unify-components.md` and `memories/M16-in-flight-record.md`. | | 17 — Hierarchical DC→AC receding-horizon dispatch | ✅ Complete | The capstone controller passes **identity-aligned SoC signposts only** (not other setpoints) from long-horizon `lossy_dc` planning into short AC-OPF windows, executes only residual-checked target-conditioned first actions, supports causal shifted initialization with audited recovery, and retains the complete plan/attempt tree. M17 fixes the validated `lossy_dc`→`ac` workflow; configurable formulations and additional layers are M21. See `plans/milestone-17-hierarchical-dc-ac.md`. | diff --git a/README.md b/README.md index c1a0b8b..3abc635 100644 --- a/README.md +++ b/README.md @@ -794,11 +794,11 @@ package environment. - [ ] SOCP network model - [x] Extend battery parameters: terminal equality/shortfall constraints and linear/quadratic terminal costs - [ ] Implement cvxpy parameters for problem data -- [ ] M14 time-vectorized multistep formulations: replace per-step CVXPY - construction with time-indexed matrix expressions and sparse temporal - operators while preserving formulation and result equivalence. This is the - current scaling priority and blocks resumption of the Case118 annual S4 outer - solve (see `plans/milestone-14-time-vectorization.md`). +- [ ] M14 time-vectorized multistep formulations: add a time-last tensor + assembly mode alongside the retained stepwise CVXPY builder, with explicit + canonicalization-backend selection and shared formulation/result semantics. + This is the current scaling priority and blocks resumption of the Case118 + annual S4 outer solve (see `plans/milestone-14-time-vectorization.md`). - [ ] Full lossy HVDC (sign-switching converter losses via charge/discharge split) and reactive power support - [x] Unify grid component model patterns (dispatchable generators, storage, nondispatchable → first-class composable components) - [x] M16+ typed component adapters and shared formulation assembly (see `plans/milestone-16-plus-component-adapters.md`) diff --git a/plans/milestone-14-time-vectorization.md b/plans/milestone-14-time-vectorization.md index 6a8c62a..ec74bf7 100644 --- a/plans/milestone-14-time-vectorization.md +++ b/plans/milestone-14-time-vectorization.md @@ -10,8 +10,11 @@ canonicalization, solve, equivalence, and resource gates below. `build_opf_multistep()` currently constructs one collection of CVXPY variables, constraints, injections, and cost expressions per time step. This preserves a -clear single-step component contract, but the Python object graph and CVXPY -canonicalization graph grow poorly with horizon length. +clear single-step component contract and correctly uses CVXPY's CPP +canonicalization backend, which is preferred for large graphs composed of many +separate expressions and constraints. The existing design is not a backend +selection defect; its Python and CVXPY object graph simply reaches a practical +scaling boundary at sufficiently large horizons. The Case118 S4 annual outer experiment made that limitation observable. Three annual workers reached the same late construction/canonicalization phase @@ -28,9 +31,185 @@ machine has 36 GiB of physical memory. Repeating the same per-step expression graph with a larger supervisor allowance is therefore not a credible annual execution strategy. -M14 replaces repeated time-step expression construction with time-indexed -matrix expressions and sparse temporal operators while preserving the -scientific formulation and public result contract. +M14 adds a second representation needed for the next scaling regime: compact, +time-vectorized N-dimensional expressions with the time axis last, paired with +CVXPY's SCIPY canonicalization backend as recommended for large sparse and +vectorized problems. It preserves the scientific formulation and public result +contract. The existing stepwise representation remains supported for +compatibility, profiling, and problem classes where it performs better. + +## Representation and canonicalization contract + +The legacy and vectorized paths are intentionally matched to different CVXPY +canonicalization backends: + +| Model representation | Canonicalization backend | Role | +|---|---|---| +| Per-step variables, expressions, and constraints constructed in a Python loop | CPP | Correct existing implementation and equivalence baseline | +| Time-vectorized arrays and N-dimensional expressions | SCIPY | Target M14 implementation and scaling path | + +Changing only the backend on the existing loop-built graph is not the M14 +intervention. Likewise, vectorizing the model while forcing CPP would ignore +the backend intended for this representation and cannot support general +expressions with dimension greater than two. Cross-combinations may be retained +as diagnostics where CVXPY supports them, but they are not required +authoritative baselines. + +The vectorized path passes `canon_backend=cp.SCIPY_CANON_BACKEND` explicitly. +It must not rely on an implicit fallback or treat CVXPY's N-dimensional SCIPY +selection warning as a defect. + +### Permanent dual temporal formulations + +M14 retains both temporal assembly modes as first-class implementations: + +- `stepwise`: the current frame-by-frame construction with one collection of + CVXPY objects per interval; and +- `vectorized`: one horizon-level construction whose final logical axis is + time. + +These are **temporal assembly modes**, not network formulations. Each must be +selectable with `ac`, `lossy_dc`, and `singlenode_dc` as its implementation +coverage is completed. Selection is explicit and retained in `OPFBuild.data`, +solve provenance, results, benchmarks, and experiment artifacts. There is no +silent horizon-length heuristic that changes assembly mode. + +The current `stepwise` behavior remains the public compatibility default during +M14. Changing a default later requires a separately reviewed API decision with +release notes and equivalence evidence. The Case118 S4 annual outer explicitly +selects `vectorized`; short M17/S3-style AC windows may continue to select +`stepwise` unless direct profiling supports a different choice. + +Temporal assembly and canonicalization backend are separate recorded choices. +Their expected primary pairings are `stepwise` + CPP and `vectorized` + SCIPY, +but profiling may evaluate other supported pairings. An unsupported pairing, +such as a CPP request for an N-dimensional expression it cannot canonicalize, +must fail validation before solve rather than silently switching backends. + +This dual contract is scientifically useful. A three-step nonlinear AC problem +can favor a different assembly/backend pairing from an 8,760-step convex +lossy-DC problem. M14 therefore reports construction, canonicalization, solver, +memory, and numerical behavior by the complete tuple: + +```text +(network formulation, temporal assembly mode, canonicalization backend, T) +``` + +For every **time-varying** per-step variable, parameter, or expression, M14 +appends time as the final axis: + +| Per-step logical shape | Vectorized logical shape | +|---|---| +| scalar `()` | `(T,)` | +| vector `(n,)` | `(n, T)` | +| matrix `(m, n)` | `(m, n, T)` | + +Genuine CVXPY tensors are permitted and expected when a per-step object is +already matrix-shaped. Flattening an intrinsic matrix axis into a two- +dimensional workaround is not the default design; it requires characterization +showing a material advantage while preserving explicit, deterministic index +semantics. + +The lifting rule does not apply to static network/device data, incidence or +admittance matrices, integrated horizon-cost scalars, or fixed boundary data. +Storage state is the deliberate boundary exception: storage power has shape +`(n_storage, T)`, while SoC has shape `(n_storage, T + 1)` because it includes +both initial and post-step boundary states. + +Existing public time-series inputs and extracted results retain their time- +first shapes `(T, ...)`. Preparation moves the public time axis to the final +internal axis once; extraction moves it back once. Device and network axes, +identity ordering, and intentional multistep `T=1` shapes remain unchanged. + +### Constants, parameters, and temporal variability + +Axis lifting is determined by a field's declared temporal semantics, not by +whether CVXPY represents it as a `Variable`, `Parameter`, `Constant`, or +implicitly promoted NumPy value. Every prepared model field belongs to one of +three closed temporal classes: + +| Temporal class | Meaning | Internal shape rule | +|---|---|---| +| `static` | One value applies to the complete horizon | Retain the native scalar/vector/matrix data; do not allocate a length-`T` copy | +| `interval` | One value may differ for every dispatch interval | Append the final axis `T` | +| `boundary` | One value may differ at every state boundary | Append the final axis `T + 1` | + +Static generator limits, voltage bounds, branch ratings, storage ratings and +capacities, cost coefficients, incidence matrices, admittance matrices, and +device identities therefore do **not** become time-expanded arrays. They are +applied to vectorized variables through ordinary linear algebra or explicit +broadcasting. A static device vector with native shape `(n,)` may receive a +singleton-axis view `(n, 1)` in algebraic expressions. Where a CVXPY leaf +attribute requires an array with exactly the variable's dimensions, the same +static vector may be exposed through a zero-stride `np.broadcast_to` view with +logical shape `(n, T)`. It must not be tiled or repeated into a physical +length-`T` copy. The broadcast view changes neither the stored data cardinality +nor its temporal classification. + +The initial SoC and terminal target are static boundary conditions with shape +`(n_storage,)`; the modeled SoC trajectory is a boundary variable with shape +`(n_storage, T + 1)`. Time-varying load, renewable availability, and any future +dynamic operating envelopes are interval fields with time last internally. + +The classification is explicit and schema-owned. It must not be inferred from +the observed values: an interval input whose values happen to be constant over +one scenario remains an interval field. Conversely, a static generator maximum +must not be expanded merely because it participates in every interval. + +Future temperature derating or other time-dependent generator limits can add +an interval `p_max` input with public shape `(T, n_generator)` and internal +shape `(n_generator, T)` without changing the vectorized generator equations. +The existing static `p_max` continues to use native shape `(n_generator,)` and +a singleton-axis broadcast view. + +M14 does not promote ordinary model constants to CVXPY `Parameter` objects as +a side effect. That remains M13's re-solve/parameterization scope. Existing +CVXPY parameters retain their ownership and gain a time axis only when their +declared field is interval- or boundary-varying. The same temporal schema must +remain valid if M13 later changes a constant field into a parameterized one. + +### Variable attributes and box constraints + +CVXPY variable attributes are the preferred candidate representation for +eligible elementwise boxes because they give the canonicalizer direct leaf- +domain information and avoid adding large explicit constraint objects to the +vectorized graph. M14 does not assume that this representation is superior for +every formulation or solver stack; it must pass the formulation-specific +qualification gate below before replacing explicit inequalities. + +For a variable with logical shape `native_shape + (T,)` or +`native_shape + (T + 1,)`: + +- static scalar bounds remain scalars when CVXPY accepts them; +- static non-scalar bounds use zero-stride `np.broadcast_to` views with exactly + the variable dimensions; +- interval- or boundary-varying bounds use their complete time-last arrays + directly; and +- lower and upper bounds are validated for finiteness, identity alignment, + exact shape, and elementwise ordering before variable construction. + +Candidate applications include independent generator active/reactive limits, +bus-voltage boxes, DC storage real-power boxes, nondispatchable +availability/rating boxes, load-shed fractions, and HVDC boxes wherever the +complete feasible set is an elementwise interval. It does not replace coupled +apparent-power circles, network equations, storage recurrence, terminal +obligations, or other non-box constraints. + +Implicit leaf bounds do not publish ordinary constraint objects or their dual +values. M14 may use them only where the public contract does not require a +named constraint or its dual. Independent primal audits continue to reconstruct +and check every physical bound from the retained result and authoritative input +arrays. + +CVXPY requires non-scalar leaf-bound arrays to have the exact variable +dimensions; it does not accept a singleton `(n, 1)` array as an implicit bound +for `(n, T)`. Preparation and model assembly must avoid a tiled Python-side +copy of static input data. Canonical bound vectors necessarily scale with the +number of bounded scalar variables, however, and M14 measures that canonical +memory separately rather than claiming zero-copy behavior through the complete +canonicalization and solver pipeline. A future M13 parameterized bound may +require a different representation if CVXPY leaf bounds cannot be backed by a +mutable `Parameter`; M14 does not preempt that decision. ## Scientific and compatibility boundary @@ -50,6 +229,47 @@ Numerical agreement is evaluated using predeclared absolute and normalized residual tolerances appropriate to each quantity. Solver trajectories and raw floating-point serialization are not required to be byte-identical. +Optimization equivalence is robust to nonunique optima. Paired stepwise and +vectorized solves must agree within tolerance on accepted objective value, +declared component-cost totals, acceptance audits, terminal obligations, and +state trajectories or other primal quantities only where those quantities are +known or predeclared to be uniquely determined. A coordinate-wise mismatch in +a genuinely nonunique dispatch, voltage, flow, or auxiliary variable is not by +itself a formulation mismatch. Each alternative primal must independently pass +the complete physical residual audit and achieve the accepted optimal objective +and declared cost decomposition. The comparison record identifies which fields +are equality-gated, residual-gated, or classified as nonunique alternatives; +it may not waive a mismatch after inspecting the outcome. + +### Representation-aware structural equivalence + +Scientific equivalence does not require accidental identity of CVXPY's source +or canonical graph. The following invariants must agree between stepwise and +vectorized formulations: + +- physical degrees of freedom and their device/network identities; +- public result dimensions, ordering, and boundary indexing; +- physical equations and feasible-set obligations represented; +- objective terms, integration units, and reconstructed component totals; +- initial, terminal, and cross-step state semantics; and +- independently reconstructed primal residuals and acceptance decisions. + +The following are representation-specific characterized quantities and are +not required to equal the legacy values: + +- Python/CVXPY variable and expression object counts; +- `len(problem.constraints)` and explicit constraint-object categories; +- leaf-domain versus explicit-bound representation; +- canonical auxiliary-variable and cone-row counts; and +- canonical sparse-matrix dimensions and nonzero counts. + +M14 records these quantities separately for every assembly/backend pairing. +Before an authoritative annual run, it freezes the expected **vectorized** +structure and canonical dimensions for the exact S4 fixture. The existing S4 +legacy counts—including 6,000 scalar variables, 2,932 scalar equalities, 7,584 +explicit scalar inequalities, and 364 constraint objects—remain the stepwise +24-hour characterization; they are not imposed on the vectorized graph. + ## Scope and sequence ### M14a — Freeze the baseline @@ -65,19 +285,53 @@ Before changing construction: artifact size over an increasing horizon ladder. 5. Preserve the failed S4 attempts as resource-boundary evidence; do not reinterpret them as solver infeasibility. +6. Freeze a typed temporal-assembly selector and provenance field without + changing the existing `stepwise` default. + +### M14a.1 — Qualify leaf bounds by formulation + +Before broad leaf-bound migration, construct paired vectorized fixtures whose +only intentional difference is explicit box inequalities versus variable +`bounds=` attributes. For lossy DC, single-node DC, and AC separately: + +1. compare feasible-set behavior, objective, public results, and independently + reconstructed residuals; +2. record source-object counts, canonical dimensions/nonzeros, construction + and canonicalization memory/time, and solver behavior; +3. exercise static and fully time-varying boxes; and +4. retain explicit inequalities for any formulation/component combination + whose numerical or solver behavior regresses. + +This gate explicitly includes the AC/DNLP risk demonstrated previously when a +`Qg` leaf bound changed the canonical structure and a formerly successful solve +failed. A convex-path result does not authorize the same representation for AC. +Leaf-bound selection is therefore formulation- and component-specific and is +retained in structural provenance. ### M14b — Vectorized horizon assembly contract Introduce an internal horizon-level assembly path with: -- variables whose leading dimension is time; +- variables and expressions whose final axis is time; +- the scalar-to-vector, vector-to-matrix, and matrix-to-tensor lifting rule + frozen above; - batched component injections, operating sets, and stage costs; -- sparse difference/selection operators for temporal coupling; +- vectorized temporal coupling, using sparse difference/selection operators + where they are the natural representation; - vectorized integration of stage costs and reported component costs; -- stable device axes and explicit time axes; and +- stable device axes and explicit time axes; +- explicit SCIPY canonicalization for the vectorized solve path; and - a deliberate compatibility adapter for the existing public `OPFBuild.variables`, expressions, and extraction contracts. +Static preparation and metadata hooks remain shared. Every active +component/formulation binding gains a vectorized horizon builder for its +time-varying variables, injections, operating set, network coupling, stage-cost +vector, and reporting expressions. The formulation builder then aggregates the +complete horizon once; it does not call the scalar step builder `T` times. +The existing stepwise hooks and builder remain executable rather than becoming +test-only dead code. + The compatibility adapter must be designed and tested explicitly. It must not materialize thousands of new CVXPY objects merely to recreate the old internal list representation. If an internal/public representation must change, freeze @@ -87,7 +341,7 @@ that change through a separately reviewed typed contract before implementation. Implement the annual-experiment blocker first: -- time-by-branch flow variables; +- branch-flow variables with shape `(n_branch, T)`; - batched nodal active-power balance; - batched branch limits and resistance-weighted loss proxy; - vectorized dispatchable-generation costs and bounds; @@ -97,9 +351,10 @@ Implement the annual-experiment blocker first: - vectorized HVDC boxes, injections, costs, and supported loss semantics; and - exact preservation of the lossy-DC audit and result schema. -The implementation should use sparse linear operators where they materially -reduce graph size. Replacing a left-deep Python sum with a balanced sum is a -useful local correction but does not, by itself, complete this stage. +The implementation should use genuine N-dimensional expressions and sparse +linear operators according to the natural algebra of each component. Replacing +a left-deep Python sum with a balanced sum is a useful local correction but +does not, by itself, complete this stage. ### M14d — Single-node DC and AC @@ -117,20 +372,43 @@ revision explicitly narrows that scope. For each implemented formulation: -1. **Structural unit tests:** dimensions, axes, identities, bounds, and sparse - temporal operators. +1. **Structural unit tests:** dimensions, time-last axes, identities, bounds, + tensor semantics, and temporal operators. + Tests distinguish `static`, `interval`, and `boundary` fields, reject + undeclared or incorrectly oriented time axes, and demonstrate that + preparation and model assembly do not create tiled Python-side copies of + static inputs. Canonical bound-vector memory is measured separately because + it necessarily scales with bounded scalar-variable count. Qualified boxes + test both static broadcast views and fully time-varying arrays; independent + primal-bound audits remain mandatory. 2. **`T=1` tests:** intentional multistep results agree with the existing single-step formulation while retaining multistep shapes. 3. **Short-horizon equivalence:** old and vectorized builders agree on - objectives, results, component costs, and independent residual audits. + objectives, declared component costs, acceptance audits, and uniquely + determined result quantities. Genuinely nonunique primal coordinates may + differ when both solutions independently pass the full residual and + optimality gates under the predeclared comparison classification. 4. **Failure equivalence:** infeasible, solver-failure, and unusable-primal records preserve their stable schemas and classifications. 5. **Component matrix:** generators, storage, loads/shedding, nondispatchable generation, and conditional HVDC paths. -6. **Scaling ladder:** increasing Case118 horizons through 24, 168, 720, and - 8,760 steps, stopping safely at predeclared resource boundaries. +6. **Formulation-specific scaling ladders:** + - lossy DC progresses through the exact 24-, 168-, 720-, and 8,760-step S4 + problem ladder; + - single-node DC progresses through a separately predeclared large horizon + sufficient to demonstrate scaling, including 8,760 when inexpensive; and + - AC uses bounded case9 and Case118 horizons selected from existing timing + and memory evidence, stopping at declared resource limits rather than + requiring an annual AC solve. 7. **Hierarchy regression:** M17 focused tests and the retained S7 equivalence gate remain clean. +8. **Backend verification:** the legacy baseline records CPP and the vectorized + path records SCIPY; performance comparisons never conflate a representation + change with an undocumented backend change. +9. **Profiling matrix:** representative short and long horizons report results + by network formulation, temporal assembly mode, canonicalization backend, + and `T`. At minimum, include short AC windows and the lossy-DC scaling + ladder; do not extrapolate the annual DC result to short nonlinear AC. Strict mypy, Ruff, the complete test suite, and `git diff --check` remain required repository gates. @@ -143,18 +421,38 @@ are true: 1. the exact frozen S4 annual inputs build through the vectorized lossy-DC path; 2. the 24-hour public-versus-streaming outer equivalence gate passes; -3. the vectorized annual model retains the expected formulation identity, - dimensions, storage identities, terminal target, and provenance hashes; -4. construction, canonicalization, and solve remain within a newly reviewed +3. the vectorized annual model matches the predeclared scientific invariants + and its separately frozen vectorized structure/dimension registry, storage + identities, terminal target, and provenance hashes; +4. execution provenance records the explicit SCIPY canonicalization backend; +5. construction, canonicalization, and solve remain within a newly reviewed memory and wall-time envelope; -5. no OS memory-pressure termination occurs; -6. the independently reconstructed outer audit is accepted; and -7. execution occurs from a clean committed source with a fresh output +6. no OS memory-pressure termination occurs; +7. the independently reconstructed outer audit is accepted; and +8. execution occurs from a clean committed source with a fresh output directory. The new annual result must identify the vectorized execution commit. It is not a continuation of any failed S4 worker. +### One annual execution, two gates + +M14 does not require an annual qualification solve followed by a duplicate S4 +solve. All cheaper M14c unit, equivalence, structural, backend, and bounded +scaling gates must pass first. The first authorized 8,760-step execution is then +launched through the exact frozen S4 supervisor, fixture, provenance, resource, +archive, and analysis protocol from a clean commit containing the reviewed M14c +implementation. + +That single execution serves simultaneously as the terminal M14c scaling gate +and the candidate authoritative S4 outer run. If every predeclared M14c and S4 +gate passes, its immutable outer artifact is promoted as the authoritative S4 +result and no repeat computation is required. If it fails, the retained record +remains M14/S4 resource, construction, solver, or audit evidence according to +its actual classification; it is never selectively promoted. Any later retry +requires the ordinary reviewed S4 rerun decision and a fresh output directory, +not a ceremonial repetition of an already accepted result. + ## Non-goals M14 does not: @@ -165,7 +463,9 @@ M14 does not: - claim that vectorization alone makes direct annual AC OPF practical; - redesign the hierarchy or shard policy; - add uncertainty, contingencies, or alternative storage physics; or -- erase the scientific value of the observed memory boundary. +- erase the scientific value of the observed memory boundary; +- remove the stepwise temporal formulation or silently select a temporal mode + from the horizon length. ## Completion criteria @@ -173,4 +473,5 @@ M14 is complete when the reviewed vectorized paths preserve the frozen mathematics and result contracts, pass the verification ladder, and demonstrate materially improved time-axis construction/canonicalization scaling. M14c is complete—and S4 may resume—when the exact 8,760-step Case118 lossy-DC outer -problem clears the annual resumption gate. +problem clears the annual resumption gate. Completion retains both stepwise and +vectorized modes as supported, profiled implementations. From 4448a2a483589fabef29bc24d813ddc3f33af561 Mon Sep 17 00:00:00 2001 From: Bennet Meyers Date: Tue, 25 Aug 2026 21:21:19 -0700 Subject: [PATCH 04/28] feat: freeze M14a temporal assembly baselines Add the explicit stepwise/vectorized temporal-assembly selector while preserving the existing stepwise default. Introduce immutable source-graph and CLARABEL canonicalization characterizations, with exact three-formulation schema and dimension regressions to anchor later vectorized equivalence. --- src/cvxopf/__init__.py | 9 +- src/cvxopf/characterization.py | 164 +++++++++++++++++++++++++++ src/cvxopf/problem.py | 174 +++++++++++++++++++---------- tests/test_m14_characterization.py | 161 ++++++++++++++++++++++++++ 4 files changed, 445 insertions(+), 63 deletions(-) create mode 100644 src/cvxopf/characterization.py create mode 100644 tests/test_m14_characterization.py diff --git a/src/cvxopf/__init__.py b/src/cvxopf/__init__.py index e378e3b..afdddbd 100644 --- a/src/cvxopf/__init__.py +++ b/src/cvxopf/__init__.py @@ -50,7 +50,13 @@ __version__ = "0.1.0" # Re-export public API -from cvxopf.problem import build_opf, build_opf_multistep, OPFOptions, OPFBuild +from cvxopf.problem import ( + build_opf, + build_opf_multistep, + OPFOptions, + OPFBuild, + TemporalAssembly, +) from cvxopf.results import extract_results, compare_to_reference from cvxopf.storage import StorageUnitIdeal from cvxopf.nondispatchable import NondispatchableUnit @@ -93,6 +99,7 @@ "build_opf_multistep", "OPFOptions", "OPFBuild", + "TemporalAssembly", "extract_results", "compare_to_reference", "StorageUnitIdeal", diff --git a/src/cvxopf/characterization.py b/src/cvxopf/characterization.py new file mode 100644 index 0000000..2a8cc70 --- /dev/null +++ b/src/cvxopf/characterization.py @@ -0,0 +1,164 @@ +"""Representation-aware structural characterization for OPF builds. + +These records describe the CVXPY source and canonical graphs without treating +representation-specific counts as scientific formulation invariants. +""" + +from __future__ import annotations + +from dataclasses import dataclass +from collections.abc import Mapping +from typing import Literal + +import cvxpy as cp + +from cvxopf.problem import OPFBuild, TemporalAssembly + + +CanonicalBackend = Literal["CPP", "SCIPY"] + + +@dataclass(frozen=True) +class NamedShape: + """One stable public mapping key and its represented CVXPY shapes.""" + + name: str + shapes: tuple[tuple[int, ...], ...] + + +@dataclass(frozen=True) +class SourceGraphStructure: + """Immutable characterization of a build's CVXPY source graph.""" + + formulation: str + temporal_assembly: TemporalAssembly + horizon: int | None + variable_schema: tuple[NamedShape, ...] + expression_schema: tuple[NamedShape, ...] + data_keys: tuple[str, ...] + parameter_shapes: tuple[tuple[int, ...], ...] + variable_object_count: int + parameter_object_count: int + constraint_object_count: int + equality_object_count: int + inequality_object_count: int + other_constraint_object_count: int + scalar_variables: int + scalar_equalities: int + scalar_inequalities: int + scalar_data: int + + +@dataclass(frozen=True) +class CanonicalGraphStructure: + """Immutable convex canonicalization dimensions for one backend.""" + + formulation: str + temporal_assembly: TemporalAssembly + backend: CanonicalBackend + solver: str + canonical_variable_count: int + equality_rows: int + nonnegative_rows: int + exponential_cones: int + second_order_cones: tuple[int, ...] + positive_semidefinite_cones: tuple[int, ...] + power_cones_3d: tuple[float, ...] + coefficient_rows: int + coefficient_columns: int + coefficient_nonzeros: int + quadratic_nonzeros: int + reduction_chain: tuple[str, ...] + + +def _shape(value: object) -> tuple[int, ...]: + raw = getattr(value, "shape", ()) + return tuple(int(item) for item in raw) + + +def _mapping_schema(mapping: Mapping[str, object]) -> tuple[NamedShape, ...]: + records: list[NamedShape] = [] + for name in sorted(mapping): + value = mapping[name] + values = value if isinstance(value, list) else [value] + records.append(NamedShape(str(name), tuple(_shape(item) for item in values))) + return tuple(records) + + +def characterize_source_graph(build: OPFBuild) -> SourceGraphStructure: + """Capture stable schemas and representation-specific source counts.""" + constraints = build.prob.constraints + equality_count = sum( + isinstance(constraint, cp.constraints.Equality) for constraint in constraints + ) + inequality_count = sum( + isinstance(constraint, cp.constraints.Inequality) for constraint in constraints + ) + metrics = build.prob.size_metrics + horizon_value = build.data.get("T") + horizon = None if horizon_value is None else int(horizon_value) + return SourceGraphStructure( + formulation=build.formulation, + temporal_assembly=build.temporal_assembly, + horizon=horizon, + variable_schema=_mapping_schema(build.variables), + expression_schema=_mapping_schema(build.expressions), + data_keys=tuple(sorted(str(key) for key in build.data)), + parameter_shapes=tuple( + sorted(_shape(parameter) for parameter in build.prob.parameters()) + ), + variable_object_count=len(build.prob.variables()), + parameter_object_count=len(build.prob.parameters()), + constraint_object_count=len(constraints), + equality_object_count=equality_count, + inequality_object_count=inequality_count, + other_constraint_object_count=( + len(constraints) - equality_count - inequality_count + ), + scalar_variables=int(metrics.num_scalar_variables), + scalar_equalities=int(metrics.num_scalar_eq_constr), + scalar_inequalities=int(metrics.num_scalar_leq_constr), + scalar_data=int(metrics.num_scalar_data), + ) + + +def characterize_convex_canonicalization( + build: OPFBuild, + *, + backend: CanonicalBackend = "CPP", +) -> CanonicalGraphStructure: + """Canonicalize for CLARABEL and retain sparse cone-program dimensions.""" + if not build.is_convex: + raise ValueError( + "convex canonical characterization does not support AC/DNLP builds" + ) + if backend not in {"CPP", "SCIPY"}: + raise ValueError("backend must be 'CPP' or 'SCIPY'") + canon_backend = cp.CPP_CANON_BACKEND if backend == "CPP" else cp.SCIPY_CANON_BACKEND + data, chain, _inverse = build.prob.get_problem_data( + cp.CLARABEL, canon_backend=canon_backend + ) + dims = data["dims"] + coefficient = data["A"] + quadratic = data.get("P") + objective = data["c"] + return CanonicalGraphStructure( + formulation=build.formulation, + temporal_assembly=build.temporal_assembly, + backend=backend, + solver=str(cp.CLARABEL), + canonical_variable_count=int(objective.shape[0]), + equality_rows=int(dims.zero), + nonnegative_rows=int(dims.nonneg), + exponential_cones=int(dims.exp), + second_order_cones=tuple(int(item) for item in dims.soc), + positive_semidefinite_cones=tuple(int(item) for item in dims.psd), + power_cones_3d=tuple(float(item) for item in dims.p3d), + coefficient_rows=int(coefficient.shape[0]), + coefficient_columns=int(coefficient.shape[1]), + coefficient_nonzeros=int(coefficient.nnz), + quadratic_nonzeros=(0 if quadratic is None else int(quadratic.nnz)), + reduction_chain=tuple( + type(reduction).__name__ for reduction in chain.reductions + ), + ) diff --git a/src/cvxopf/problem.py b/src/cvxopf/problem.py index 10daf66..1d4abb4 100644 --- a/src/cvxopf/problem.py +++ b/src/cvxopf/problem.py @@ -22,6 +22,7 @@ import warnings from dataclasses import dataclass, field from numbers import Real +from typing import Any, Callable, Literal import numpy as np import pandas as pd @@ -44,10 +45,14 @@ from cvxopf.data import align_device_dataframe, load_timeseries_from_dataframe +TemporalAssembly = Literal["stepwise", "vectorized"] + + # --------------------------------------------------------------------------- # Options dataclass # --------------------------------------------------------------------------- + @dataclass class OPFOptions: """ @@ -101,19 +106,21 @@ class OPFOptions: OPFOptions is accepted for API consistency but all fields are ignored when formulation='singlenode_dc'. """ - enforce_vset: bool = False - sparsity_tol: float = 0.0 - init_flat: bool = True - enforce_branch_limits: bool = True - loss_weight: float = 1.0 - branch_limit_sentinel: float = 1e6 - sparse_pq: bool = True + + enforce_vset: bool = False + sparsity_tol: float = 0.0 + init_flat: bool = True + enforce_branch_limits: bool = True + loss_weight: float = 1.0 + branch_limit_sentinel: float = 1e6 + sparse_pq: bool = True # --------------------------------------------------------------------------- # Return type # --------------------------------------------------------------------------- + @dataclass class OPFBuild: """ @@ -218,15 +225,21 @@ class OPFBuild: ``load_shed_fraction``, and ``p_load_shed_total``. The integrated stage cost is ``load_shedding_cost``; horizon expressions are ``energy_not_served_by_load`` and ``energy_not_served``. + temporal_assembly : {"stepwise", "vectorized"} + Temporal graph representation retained as build provenance. Existing + single- and multistep builders use ``"stepwise"`` until the M14 + horizon-vectorized implementation is selected explicitly. """ - prob: cp.Problem - variables: dict - data: dict + + prob: cp.Problem + variables: dict[str, Any] + data: dict[str, Any] formulation: str - is_convex: bool - expressions: dict = field(default_factory=dict) + is_convex: bool + expressions: dict[str, Any] = field(default_factory=dict) + temporal_assembly: TemporalAssembly = "stepwise" - def solve(self, **kwargs) -> None: + def solve(self, **kwargs: Any) -> None: """ Solve the OPF problem with appropriate solver defaults. @@ -269,27 +282,38 @@ def solve(self, **kwargs) -> None: self.prob.solve(**kwargs) +def _finalize_temporal_assembly( + build: OPFBuild, temporal_assembly: TemporalAssembly +) -> OPFBuild: + """Bind the selected temporal representation to build provenance.""" + build.temporal_assembly = temporal_assembly + return build + + # --------------------------------------------------------------------------- # Dispatch tables (populated after imports to avoid circular imports) # --------------------------------------------------------------------------- -def _get_single_builders(): + +def _get_single_builders() -> dict[str, Callable[..., OPFBuild]]: from cvxopf.ac_problem import _build_ac_single from cvxopf.dc_problem import _build_lossy_dc_single from cvxopf.singlenode_dc_problem import _build_singlenode_dc_single + return { - "ac": _build_ac_single, + "ac": _build_ac_single, "lossy_dc": _build_lossy_dc_single, "singlenode_dc": _build_singlenode_dc_single, } -def _get_multistep_builders(): +def _get_multistep_builders() -> dict[str, Callable[..., OPFBuild]]: from cvxopf.ac_problem import _build_ac_multistep from cvxopf.dc_problem import _build_lossy_dc_multistep from cvxopf.singlenode_dc_problem import _build_singlenode_dc_multistep + return { - "ac": _build_ac_multistep, + "ac": _build_ac_multistep, "lossy_dc": _build_lossy_dc_multistep, "singlenode_dc": _build_singlenode_dc_multistep, } @@ -309,7 +333,7 @@ def _validate_temporal_delta(delta: float) -> None: def _normalize_multistep_load_inputs( - case: dict, + case: dict[str, Any], df_P: pd.DataFrame | None, df_Q: pd.DataFrame | None, loads: list[Load] | None, @@ -350,21 +374,14 @@ def _normalize_multistep_load_inputs( if df_load_p is None: p_mw = np.tile([unit.p_load_mw for unit in loads], (T, 1)) else: - p_mw = align_device_dataframe( - df_load_p, loads, T, "df_load_p" - ) + p_mw = align_device_dataframe(df_load_p, loads, T, "df_load_p") if df_load_q is None: q_mvar = np.tile( - [ - 0.0 if unit.q_load_mvar is None else unit.q_load_mvar - for unit in loads - ], + [0.0 if unit.q_load_mvar is None else unit.q_load_mvar for unit in loads], (T, 1), ) else: - q_mvar = align_device_dataframe( - df_load_q, loads, T, "df_load_q" - ) + q_mvar = align_device_dataframe(df_load_q, loads, T, "df_load_q") has_reactive = np.asarray( [unit.q_load_mvar is not None for unit in loads], dtype=bool ) @@ -377,8 +394,9 @@ def _normalize_multistep_load_inputs( # Public API # --------------------------------------------------------------------------- + def build_opf( - case: dict, + case: dict[str, Any], *, formulation: str = "ac", options: OPFOptions | None = None, @@ -454,21 +472,28 @@ def build_opf( builders = _get_single_builders() if formulation not in builders: raise ValueError( - f"Unknown formulation '{formulation}'. " - f"Supported: {sorted(builders.keys())}" + f"Unknown formulation '{formulation}'. Supported: {sorted(builders.keys())}" ) normalized_case = ( - _case_with_generators(case, generators) - if generators is not None else case + _case_with_generators(case, generators) if generators is not None else case ) - return builders[formulation]( - normalized_case, options, storage, delta, nondispatchable, - hvdc=hvdc, generators=generators, loads=loads, + return _finalize_temporal_assembly( + builders[formulation]( + normalized_case, + options, + storage, + delta, + nondispatchable, + hvdc=hvdc, + generators=generators, + loads=loads, + ), + "stepwise", ) def build_opf_multistep( - case: dict, + case: dict[str, Any], df_P: pd.DataFrame | None = None, df_Q: pd.DataFrame | None = None, *, @@ -487,6 +512,7 @@ def build_opf_multistep( loads: list[Load] | None = None, df_load_p: pd.DataFrame | None = None, df_load_q: pd.DataFrame | None = None, + temporal_assembly: TemporalAssembly = "stepwise", ) -> OPFBuild: """ Build a T-step OPF problem as a single cp.Problem. @@ -522,6 +548,11 @@ def build_opf_multistep( T : int Number of time steps. Must equal the row count of every supplied load trajectory; static explicit-load fallback is tiled to this length. + temporal_assembly : {"stepwise", "vectorized"}, optional + Temporal graph representation. ``"stepwise"`` preserves the existing + per-interval builder and remains the compatibility default. The + ``"vectorized"`` selector is reserved by M14 and is rejected until + its horizon-level implementation is available. formulation : str Same options as build_opf, including "singlenode_dc" (single-node copper-plate DC dispatch; df_Q reporting-only). @@ -562,6 +593,13 @@ def build_opf_multistep( """ if options is None: options = OPFOptions() + if temporal_assembly not in {"stepwise", "vectorized"}: + raise ValueError("temporal_assembly must be 'stepwise' or 'vectorized'") + if temporal_assembly == "vectorized": + raise NotImplementedError( + "temporal_assembly='vectorized' is reserved for the M14b " + "horizon-level implementation" + ) if coupling_constraints is None: coupling_constraints = [] if generators is not None and len(generators) == 0: @@ -575,8 +613,7 @@ def build_opf_multistep( builders = _get_multistep_builders() if formulation not in builders: raise ValueError( - f"Unknown formulation '{formulation}'. " - f"Supported: {sorted(builders.keys())}" + f"Unknown formulation '{formulation}'. Supported: {sorted(builders.keys())}" ) load_inputs, explicit_load_mode = _normalize_multistep_load_inputs( @@ -631,16 +668,10 @@ def build_opf_multistep( df_hvdc_min = pd.DataFrame(np.tile(p_min_static, (T, 1))) df_hvdc_max = pd.DataFrame(np.tile(p_max_static, (T, 1))) elif df_hvdc_min is None or df_hvdc_max is None: - raise ValueError( - "df_hvdc_min and df_hvdc_max must be provided together." - ) + raise ValueError("df_hvdc_min and df_hvdc_max must be provided together.") else: - mins = _parse_hvdc_timeseries( - df_hvdc_min, hvdc, T, "df_hvdc_min" - ) - maxs = _parse_hvdc_timeseries( - df_hvdc_max, hvdc, T, "df_hvdc_max" - ) + mins = _parse_hvdc_timeseries(df_hvdc_min, hvdc, T, "df_hvdc_min") + maxs = _parse_hvdc_timeseries(df_hvdc_max, hvdc, T, "df_hvdc_max") if np.any(mins > maxs): bad = np.argwhere(mins > maxs) t_bad, k_bad = bad[0] @@ -654,8 +685,7 @@ def build_opf_multistep( df_hvdc_max = pd.DataFrame(maxs, columns=aligned_ids) elif not hvdc and (df_hvdc_min is not None or df_hvdc_max is not None): warnings.warn( - "df_hvdc_min/df_hvdc_max are ignored because no HVDC links " - "were provided.", + "df_hvdc_min/df_hvdc_max are ignored because no HVDC links were provided.", UserWarning, stacklevel=2, ) @@ -663,15 +693,29 @@ def build_opf_multistep( df_hvdc_max = None normalized_case = ( - _case_with_generators(case, generators) - if generators is not None else case + _case_with_generators(case, generators) if generators is not None else case ) - return builders[formulation]( - normalized_case, df_P, df_Q, T, options, coupling_constraints, - storage, delta, nondispatchable, df_nd, - hvdc=hvdc, df_hvdc_min=df_hvdc_min, df_hvdc_max=df_hvdc_max, - generators=generators, loads=loads, load_inputs=load_inputs, - load_participates_when_empty=explicit_load_mode, + return _finalize_temporal_assembly( + builders[formulation]( + normalized_case, + df_P, + df_Q, + T, + options, + coupling_constraints, + storage, + delta, + nondispatchable, + df_nd, + hvdc=hvdc, + df_hvdc_min=df_hvdc_min, + df_hvdc_max=df_hvdc_max, + generators=generators, + loads=loads, + load_inputs=load_inputs, + load_participates_when_empty=explicit_load_mode, + ), + temporal_assembly, ) @@ -679,8 +723,9 @@ def build_opf_multistep( # Deprecated aliases # --------------------------------------------------------------------------- + def build_acopf( - case: dict, + case: dict[str, Any], *, options: OPFOptions | None = None, ) -> OPFBuild: @@ -701,7 +746,7 @@ def build_acopf( def build_acopf_multistep( - case: dict, + case: dict[str, Any], df_P: pd.DataFrame, df_Q: pd.DataFrame, *, @@ -724,6 +769,11 @@ def build_acopf_multistep( stacklevel=2, ) return build_opf_multistep( - case, df_P, df_Q, T=T, formulation="ac", - options=options, coupling_constraints=coupling_constraints, + case, + df_P, + df_Q, + T=T, + formulation="ac", + options=options, + coupling_constraints=coupling_constraints, ) diff --git a/tests/test_m14_characterization.py b/tests/test_m14_characterization.py new file mode 100644 index 0000000..02c0d60 --- /dev/null +++ b/tests/test_m14_characterization.py @@ -0,0 +1,161 @@ +"""M14a frozen characterization of the legacy temporal graph.""" + +from contextlib import nullcontext +from dataclasses import FrozenInstanceError, asdict +import hashlib +import json + +import cvxpy as cp +import numpy as np +import pandas as pd +import pytest + +from cvxopf import build_opf, build_opf_multistep +from cvxopf.characterization import ( + characterize_convex_canonicalization, + characterize_source_graph, +) +from cvxopf.testcases import case9 + + +SOURCE_GRAPH_DIGESTS = { + "ac": "7f69a7694e27983d48fc071ee1cfd84b58fba371aa22bda27b6ebe9347767633", + "lossy_dc": "90f376331ca7912f068e96875a6296ddb868b7debab64e8d566d542627eaecd4", + "singlenode_dc": ( + "e19b20b4ea86588fdf45210b3df3217691faf27cfd055d7ccc1673fcab09ad5f" + ), +} + +REDUCTION_CHAIN = ( + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL", +) + +CANONICAL_BASELINES = { + "lossy_dc": (48, 24, 66, 0, (), (), (), 90, 48, 156, 18, REDUCTION_CHAIN), + "singlenode_dc": (12, 8, 12, 0, (), (), (), 20, 12, 30, 6, REDUCTION_CHAIN), +} + + +def _digest(value: object) -> str: + encoded = json.dumps(asdict(value), sort_keys=True, separators=(",", ":")).encode() + return hashlib.sha256(encoded).hexdigest() + + +def _frames(T: int) -> tuple[pd.DataFrame, pd.DataFrame]: + ppc = case9() + return ( + pd.DataFrame(np.tile(ppc["bus"][:, 2], (T, 1))), + pd.DataFrame(np.tile(ppc["bus"][:, 3], (T, 1))), + ) + + +@pytest.mark.parametrize( + ("formulation", "expected"), + [ + ("ac", (264, 254, 60, 24, 170)), + ("lossy_dc", (24, 18, 30, 4, 8)), + ("singlenode_dc", (6, 2, 12, 2, 6)), + ], +) +def test_stepwise_source_graph_baseline(formulation, expected): + active, reactive = _frames(2) + context = pytest.warns(UserWarning) if formulation != "ac" else nullcontext() + with context: + build = build_opf_multistep( + case9(), active, reactive, T=2, formulation=formulation + ) + + record = characterize_source_graph(build) + + assert build.temporal_assembly == "stepwise" + assert "temporal_assembly" not in build.data + assert record.temporal_assembly == "stepwise" + assert record.horizon == 2 + assert ( + record.scalar_variables, + record.scalar_equalities, + record.scalar_inequalities, + record.variable_object_count, + record.constraint_object_count, + ) == expected + # This digest binds the complete variable/expression/parameter/data schema + # and every source-graph count, while the assertions above keep the main + # scientific dimensions readable in a failure report. + assert _digest(record) == SOURCE_GRAPH_DIGESTS[formulation] + + +def test_temporal_selector_is_closed_and_vectorized_is_reserved(): + active, reactive = _frames(1) + with pytest.raises(ValueError, match="temporal_assembly"): + build_opf_multistep( + case9(), + active, + reactive, + T=1, + temporal_assembly="other", # type: ignore[arg-type] + ) + with pytest.raises(NotImplementedError, match="M14b"): + build_opf_multistep( + case9(), + active, + reactive, + T=1, + temporal_assembly="vectorized", + ) + + +def test_single_step_build_records_stepwise_provenance(): + build = build_opf(case9(), formulation="lossy_dc") + assert build.temporal_assembly == "stepwise" + assert characterize_source_graph(build).horizon is None + + +@pytest.mark.parametrize("formulation", ["lossy_dc", "singlenode_dc"]) +def test_cpp_and_scipy_characterizations_retain_backend_identity(formulation): + active, _reactive = _frames(2) + build = build_opf_multistep(case9(), active, T=2, formulation=formulation) + + cpp = characterize_convex_canonicalization(build, backend="CPP") + scipy = characterize_convex_canonicalization(build, backend="SCIPY") + + assert cpp.backend == "CPP" + assert scipy.backend == "SCIPY" + assert cpp.solver == str(cp.CLARABEL) + assert cpp.canonical_variable_count == scipy.canonical_variable_count + assert cpp.equality_rows == scipy.equality_rows + assert cpp.nonnegative_rows == scipy.nonnegative_rows + assert cpp.coefficient_nonzeros == scipy.coefficient_nonzeros + assert cpp.quadratic_nonzeros == scipy.quadratic_nonzeros + expected = CANONICAL_BASELINES[formulation] + for record in (cpp, scipy): + assert ( + record.canonical_variable_count, + record.equality_rows, + record.nonnegative_rows, + record.exponential_cones, + record.second_order_cones, + record.positive_semidefinite_cones, + record.power_cones_3d, + record.coefficient_rows, + record.coefficient_columns, + record.coefficient_nonzeros, + record.quadratic_nonzeros, + record.reduction_chain, + ) == expected + + +def test_characterization_records_are_immutable(): + build = build_opf(case9(), formulation="singlenode_dc") + record = characterize_source_graph(build) + with pytest.raises(FrozenInstanceError): + record.horizon = 5 # type: ignore[misc] + + +def test_convex_canonicalizer_rejects_ac_dnlp(): + build = build_opf(case9(), formulation="ac") + with pytest.raises(ValueError, match="AC/DNLP"): + characterize_convex_canonicalization(build) From 4e89b31e0e2de0239d9cb168dfdc40600e740f5e Mon Sep 17 00:00:00 2001 From: Bennet Meyers Date: Tue, 25 Aug 2026 21:42:37 -0700 Subject: [PATCH 05/28] feat: add M14a legacy scaling and audit harness Freeze feasible, infeasible, and full-component baselines across all three formulations with independent physical audits. Add isolated timing and RSS measurements, source-bound supervision, explicit timeouts, and immutable hashed artifacts for the legacy scaling ladder. --- .../m14_time_vectorization/M14A_PROTOCOL.md | 36 ++ .../m14_time_vectorization/__init__.py | 1 + .../m14_time_vectorization/baseline.py | 372 +++++++++++++++ .../m14_time_vectorization/run_m14a.py | 444 ++++++++++++++++++ tests/test_m14a_baseline.py | 311 ++++++++++++ 5 files changed, 1164 insertions(+) create mode 100644 experiments/m14_time_vectorization/M14A_PROTOCOL.md create mode 100644 experiments/m14_time_vectorization/__init__.py create mode 100644 experiments/m14_time_vectorization/baseline.py create mode 100644 experiments/m14_time_vectorization/run_m14a.py create mode 100644 tests/test_m14a_baseline.py diff --git a/experiments/m14_time_vectorization/M14A_PROTOCOL.md b/experiments/m14_time_vectorization/M14A_PROTOCOL.md new file mode 100644 index 0000000..7ccf1b6 --- /dev/null +++ b/experiments/m14_time_vectorization/M14A_PROTOCOL.md @@ -0,0 +1,36 @@ +# M14a legacy baseline protocol + +M14a characterizes the existing per-step temporal graph before vectorized +assembly changes it. The legacy representation is explicitly `stepwise`; its +convex canonicalization baseline is CPP. AC uses the existing DNLP/IPOPT path. + +Each scaling point runs in a fresh process so process-lifetime peak RSS is +meaningful and cannot inherit an earlier point's high-water mark. A record +retains construction, explicit convex canonicalization, solve, and extraction +times; phase-boundary peak RSS; source and canonical graph dimensions; result +schema and values; independently reconstructed physical residuals; status; and +strict-JSON result size. For AC, DNLP +canonicalization remains included in solve time because CVXPY exposes it +through the nonlinear solve path rather than `Problem.get_problem_data()`. + +The deterministic feasible fixture uses fixed Case9 loads and one hard-target +storage unit whose initial and terminal SoC are both 50 MWh. The failure +fixture changes the same device to an unreachable 0-to-100 MWh transition, +producing genuine solver-certified infeasibility rather than a synthetic status +rewrite. Case118 scaling uses the same declared storage fixture and native case +loads; it is characterization only and is not the Case118 annual experiment. +The full component fixture additionally exercises one sheddable load, +time-varying nondispatchable availability, and an HVDC transfer alongside +storage. Singlenode DC deliberately retains the applicable components while +omitting its unsupported HVDC path. + +Machine-dependent times and RSS values are observations, not portable golden +tests. Source/result schemas and graph dimensions are frozen separately in the +focused M14 tests. Every worker records its commit, source fingerprint, +worktree state, platform, architecture, and solver-stack versions. The parent +manifest validates every worker against the parent's commit and source +fingerprint, then hashes every retained result, phase journal, and log artifact. +Scaling stops after the first +unsuccessful or timed-out worker for each formulation and preserves that +classification in the immutable manifest. The default per-point wall limit is +1,800 seconds and authoritative runs must record any reviewed override. diff --git a/experiments/m14_time_vectorization/__init__.py b/experiments/m14_time_vectorization/__init__.py new file mode 100644 index 0000000..8f0099c --- /dev/null +++ b/experiments/m14_time_vectorization/__init__.py @@ -0,0 +1 @@ +"""M14 time-vectorization characterization experiments.""" diff --git a/experiments/m14_time_vectorization/baseline.py b/experiments/m14_time_vectorization/baseline.py new file mode 100644 index 0000000..c7cbb65 --- /dev/null +++ b/experiments/m14_time_vectorization/baseline.py @@ -0,0 +1,372 @@ +"""Deterministic M14a successful and infeasible baseline fixtures.""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import Any, Literal, cast +import warnings + +import numpy as np +import pandas as pd + +from cvxopf import ( + HVDCLink, + Load, + NondispatchableUnit, + OPFBuild, + StorageUnitIdeal, + build_opf_multistep, +) +from cvxopf.testcases import case9, case118 + + +BaselineCase = Literal["case9", "case118"] +BaselineOutcome = Literal["feasible", "infeasible"] +BaselineComponents = Literal["core", "full"] + + +@dataclass(frozen=True) +class BaselineFixture: + """One deterministic build-ready legacy temporal fixture.""" + + case_name: BaselineCase + formulation: str + horizon: int + outcome: BaselineOutcome + components: BaselineComponents + build: OPFBuild + + +def _case(case_name: BaselineCase) -> dict[str, Any]: + return cast(dict[str, Any], case9() if case_name == "case9" else case118()) + + +def build_baseline_fixture( + formulation: str, + *, + horizon: int = 2, + outcome: BaselineOutcome = "feasible", + case_name: BaselineCase = "case9", + components: BaselineComponents = "core", +) -> BaselineFixture: + """Construct a fixed-load, storage-coupled stepwise baseline.""" + if horizon <= 0: + raise ValueError("horizon must be positive") + if formulation not in {"ac", "lossy_dc", "singlenode_dc"}: + raise ValueError("unsupported formulation") + if outcome not in {"feasible", "infeasible"}: + raise ValueError("unsupported outcome") + if components not in {"core", "full"}: + raise ValueError("unsupported component fixture") + if components == "full" and outcome == "infeasible": + raise ValueError("the full component fixture is successful-only") + if outcome == "infeasible" and horizon >= 100: + raise ValueError("the one-MW unreachable-target fixture requires horizon < 100") + ppc = _case(case_name) + active = pd.DataFrame(np.tile(ppc["bus"][:, 2], (horizon, 1))) + reactive = pd.DataFrame(np.tile(ppc["bus"][:, 3], (horizon, 1))) + infeasible = outcome == "infeasible" + storage = StorageUnitIdeal( + bus=5, + apparent_power_rating=1.0 if infeasible else 10.0, + capacity=100.0, + initial_soc=0.0 if infeasible else 50.0, + terminal_soc=100.0 if infeasible else 50.0, + terminal_constraint="equality", + device_id="m14a-storage", + ) + loads = None + load_active = None + load_reactive = None + nondispatchable = None + nd_available = None + hvdc = None + hvdc_min = None + hvdc_max = None + legacy_active = active + legacy_reactive = reactive + if components == "full": + load_rows = [row for row in ppc["bus"] if row[2] != 0.0 or row[3] != 0.0] + loads = [ + Load( + bus=int(row[0]), + p_load_mw=float(row[2]), + q_load_mvar=float(row[3]), + device_id=f"load-{int(row[0])}", + shedding_cost_per_mwh=(10_000.0 if index == 0 else None), + max_shed_fraction=(0.1 if index == 0 else 1.0), + ) + for index, row in enumerate(load_rows) + ] + load_active = pd.DataFrame( + np.tile([load.p_load_mw for load in loads], (horizon, 1)), + columns=[load.device_id for load in loads], + ) + load_reactive = pd.DataFrame( + np.tile([load.q_load_mvar for load in loads], (horizon, 1)), + columns=[load.device_id for load in loads], + ) + nondispatchable = [NondispatchableUnit(6, 5.0, 6.0, "m14a-renewable")] + nd_available = pd.DataFrame( + np.linspace(4.0, 5.0, horizon)[:, None], + columns=["m14a-renewable"], + ) + hvdc = [HVDCLink(1, 2, -2.0, -0.5, 1.0, device_id="m14a-hvdc")] + hvdc_min = pd.DataFrame(np.full((horizon, 1), -2.0), columns=["m14a-hvdc"]) + hvdc_max = pd.DataFrame(np.full((horizon, 1), -0.5), columns=["m14a-hvdc"]) + legacy_active = None + legacy_reactive = None + with warnings.catch_warnings(): + warnings.filterwarnings( + "ignore", message=r"df_(Q|load_q) is retained as reactive load input" + ) + warnings.filterwarnings( + "ignore", + message="Storage apparent_power_rating is applied as a real power", + ) + build = build_opf_multistep( + ppc, + legacy_active, + legacy_reactive, + T=horizon, + formulation=formulation, + storage=[storage], + loads=loads, + df_load_p=load_active, + df_load_q=load_reactive, + nondispatchable=nondispatchable, + df_nd=nd_available, + hvdc=hvdc, + df_hvdc_min=hvdc_min, + df_hvdc_max=hvdc_max, + temporal_assembly="stepwise", + ) + return BaselineFixture(case_name, formulation, horizon, outcome, components, build) + + +def result_schema(result: dict[str, Any]) -> dict[str, dict[str, Any]]: + """Describe result availability, scalar kind, shape, and dtype.""" + schema: dict[str, dict[str, Any]] = {} + for name in sorted(result): + value = result[name] + if value is None: + schema[name] = {"availability": "unavailable"} + elif isinstance(value, str): + schema[name] = {"availability": "value", "kind": "string"} + elif np.isscalar(value): + scalar = float(value) + schema[name] = { + "availability": ( + "nonfinite_scalar" if not np.isfinite(scalar) else "value" + ), + "kind": "scalar", + } + else: + array = np.asarray(value) + schema[name] = { + "availability": "value", + "kind": "array", + "shape": list(array.shape), + "dtype_kind": array.dtype.kind, + } + return schema + + +def json_result(result: dict[str, Any]) -> dict[str, Any]: + """Convert result values to strict-JSON-compatible scientific payloads.""" + payload: dict[str, Any] = {} + for name, value in result.items(): + if value is None: + payload[name] = None + elif isinstance(value, str): + payload[name] = value + elif np.isscalar(value): + scalar = float(value) + payload[name] = scalar if np.isfinite(scalar) else None + else: + array = np.asarray(value) + payload[name] = array.tolist() + return payload + + +def _maximum_violation( + values: np.ndarray, lower: np.ndarray | float, upper: np.ndarray | float +) -> float: + return float( + max( + 0.0, + np.max(np.asarray(lower) - values), + np.max(values - np.asarray(upper)), + ) + ) + + +def audit_result(fixture: BaselineFixture, result: dict[str, Any]) -> dict[str, float]: + """Independently reconstruct common and formulation-specific residuals.""" + build = fixture.build + data = build.data + base = float(data["baseMVA"]) + generation = np.asarray(result["Pg"], dtype=float) + storage_power = np.asarray(result["b"], dtype=float) + state = np.asarray(result["soc"], dtype=float) + served = np.asarray(result["p_load_served"], dtype=float) + modeled = generation @ np.asarray(data["Cg"], dtype=float).T + modeled += storage_power @ np.asarray(data["Cs"], dtype=float).T + modeled -= served @ np.asarray(data["Cload"], dtype=float).T + if result.get("p_nd") is not None: + modeled += ( + np.asarray(result["p_nd"], dtype=float) + @ np.asarray(data["Cnd"], dtype=float).T + ) + if result.get("p_hvdc_in") is not None: + modeled += ( + np.asarray(result["p_hvdc_in"], dtype=float) + @ np.asarray(data["Ch_from"], dtype=float).T + ) + modeled += ( + np.asarray(result["p_hvdc_out"], dtype=float) + @ np.asarray(data["Ch_to"], dtype=float).T + ) + network = np.asarray(result["p_net"], dtype=float) + if network.ndim == 1: + network = network[:, None] + preceding = np.vstack((np.asarray(data["storage_initial_soc"]), state[:-1])) + residuals = { + "active_nodal_balance_mw_abs": float(np.max(np.abs(network - modeled))), + "generator_active_bound_mw_abs": _maximum_violation( + generation, + base * np.asarray(data["Pgmin"]), + base * np.asarray(data["Pgmax"]), + ), + "storage_recurrence_mwh_abs": float( + np.max( + np.abs( + state - (preceding - float(data["storage_delta"]) * storage_power) + ) + ) + ), + "storage_energy_bound_mwh_abs": _maximum_violation( + state, 0.0, np.asarray(data["storage_capacity"]) + ), + "terminal_soc_mwh_abs": float( + np.max(np.abs(state[-1] - np.asarray(data["storage_terminal_soc"]))) + ), + } + ratings = np.asarray(data["storage_apparent_power_rating"], dtype=float) + if result.get("b_q") is None: + storage_magnitude = np.abs(storage_power) + else: + storage_magnitude = np.hypot( + storage_power, np.asarray(result["b_q"], dtype=float) + ) + residuals["storage_power_bound_mva_abs"] = _maximum_violation( + storage_magnitude, 0.0, ratings + ) + + load = np.asarray(result["p_load"], dtype=float) + expected_served = load.copy() + fractions = result.get("load_shed_fraction") + if fractions is not None: + indices = np.asarray(data["sheddable_load_indices"], dtype=int) + fraction_values = np.asarray(fractions, dtype=float) + expected_served[:, indices] = load[:, indices] - fraction_values * np.maximum( + load[:, indices], 0.0 + ) + residuals["load_shed_fraction_bound_abs"] = _maximum_violation( + fraction_values, + 0.0, + np.asarray(data["load_max_shed_fraction"])[indices], + ) + residuals["active_load_service_mw_abs"] = float( + np.max(np.abs(served - expected_served)) + ) + + if result.get("curtailment") is not None: + curtailment = np.asarray(result["curtailment"], dtype=float) + residuals["curtailment_nonnegativity_mw_abs"] = float( + max(0.0, -np.min(curtailment)) + ) + nd_active = np.asarray(result["p_nd"], dtype=float) + residuals["nondispatchable_active_bound_mw_abs"] = _maximum_violation( + nd_active, 0.0, np.asarray(data["nd_available"], dtype=float) + ) + if result.get("hvdc_loss") is not None: + losses = np.asarray(result["hvdc_loss"], dtype=float) + residuals["hvdc_loss_nonnegativity_mw_abs"] = float(max(0.0, -np.min(losses))) + hvdc_in = np.asarray(result["p_hvdc_in"], dtype=float) + hvdc_out = np.asarray(result["p_hvdc_out"], dtype=float) + residuals["hvdc_box_mw_abs"] = _maximum_violation(hvdc_in, -2.0, -0.5) + residuals["hvdc_transfer_identity_mw_abs"] = float( + np.max(np.abs(hvdc_out + 0.99 * hvdc_in)) + ) + + if fixture.formulation == "ac": + reactive = ( + np.asarray(result["Qg"], dtype=float) + @ np.asarray(data["Cg"], dtype=float).T + ) + reactive += ( + np.asarray(result["b_q"], dtype=float) + @ np.asarray(data["Cs"], dtype=float).T + ) + reactive -= ( + np.asarray(result["q_load_served"], dtype=float) + @ np.asarray(data["Cload"], dtype=float).T + ) + if result.get("q_nd") is not None: + nd_reactive = np.asarray(result["q_nd"], dtype=float) + reactive += nd_reactive @ np.asarray(data["Cnd"], dtype=float).T + residuals["nondispatchable_apparent_bound_mva_abs"] = _maximum_violation( + np.hypot(np.asarray(result["p_nd"], dtype=float), nd_reactive), + 0.0, + np.asarray(data["nd_apparent_power_rating"], dtype=float), + ) + residuals["reactive_nodal_balance_mvar_abs"] = float( + np.max(np.abs(np.asarray(result["q_net"], dtype=float) - reactive)) + ) + expected_q_served = np.asarray(result["q_load"], dtype=float).copy() + if fractions is not None: + expected_q_served[:, indices] *= 1.0 - fraction_values + residuals["reactive_load_service_mvar_abs"] = float( + np.max( + np.abs( + np.asarray(result["q_load_served"], dtype=float) - expected_q_served + ) + ) + ) + residuals["generator_reactive_bound_mvar_abs"] = _maximum_violation( + np.asarray(result["Qg"], dtype=float), + base * np.asarray(data["Qgmin"]), + base * np.asarray(data["Qgmax"]), + ) + ppc = _case(fixture.case_name) + voltage = np.asarray(result["Vm"], dtype=float) + residuals["voltage_bound_pu_abs"] = _maximum_violation( + voltage, ppc["bus"][:, 12], ppc["bus"][:, 11] + ) + branch_limit = np.asarray(data["branch_rate_a_mva"], dtype=float) + branch_magnitude = np.maximum( + np.asarray(result["branch_s_from"], dtype=float), + np.asarray(result["branch_s_to"], dtype=float), + ) + residuals["thermal_limit_mva_abs"] = _maximum_violation( + branch_magnitude, 0.0, branch_limit + ) + branch_loss = np.asarray(result["branch_p_from"], dtype=float) + np.asarray( + result["branch_p_to"], dtype=float + ) + residuals["branch_loss_nonnegativity_mw_abs"] = float( + max(0.0, -np.min(branch_loss)) + ) + elif fixture.formulation == "lossy_dc": + residuals["thermal_limit_mw_abs"] = _maximum_violation( + np.asarray(result["p_flows"], dtype=float), + -base * np.asarray(data["f_max"]), + base * np.asarray(data["f_max"]), + ) + dc_loss = ( + np.asarray(data["r"], dtype=float) + * np.asarray(result["p_flows"], dtype=float) ** 2 + ) + residuals["dc_loss_nonnegativity_abs"] = float(max(0.0, -np.min(dc_loss))) + return residuals diff --git a/experiments/m14_time_vectorization/run_m14a.py b/experiments/m14_time_vectorization/run_m14a.py new file mode 100644 index 0000000..7daa104 --- /dev/null +++ b/experiments/m14_time_vectorization/run_m14a.py @@ -0,0 +1,444 @@ +"""Isolated legacy scaling measurements for the M14a baseline.""" + +from __future__ import annotations + +import argparse +from dataclasses import asdict +import hashlib +from importlib.metadata import PackageNotFoundError, version +import json +import os +from pathlib import Path +import platform +import resource +import subprocess +import sys +import time +from collections.abc import Callable +from typing import Any, cast + +import cvxpy as cp + +from cvxopf.characterization import ( + characterize_convex_canonicalization, + characterize_source_graph, +) +from cvxopf.results import extract_results +from experiments.m14_time_vectorization.baseline import ( + BaselineCase, + audit_result, + build_baseline_fixture, + json_result, + result_schema, +) + + +FORMULATIONS = ("ac", "lossy_dc", "singlenode_dc") +ROOT = Path(__file__).resolve().parents[2] + + +def _sha256(path: Path) -> str: + digest = hashlib.sha256() + with path.open("rb") as stream: + for block in iter(lambda: stream.read(1024 * 1024), b""): + digest.update(block) + return digest.hexdigest() + + +def _source_fingerprint() -> str: + paths = sorted((ROOT / "src" / "cvxopf").rglob("*.py")) + sorted( + (ROOT / "experiments" / "m14_time_vectorization").rglob("*.py") + ) + digest = hashlib.sha256() + for path in paths: + digest.update(path.relative_to(ROOT).as_posix().encode()) + digest.update(b"\0") + digest.update(path.read_bytes()) + digest.update(b"\0") + return digest.hexdigest() + + +def _git(*arguments: str) -> str | None: + completed = subprocess.run( + ["git", *arguments], + cwd=ROOT, + check=False, + capture_output=True, + text=True, + ) + return completed.stdout.strip() if completed.returncode == 0 else None + + +def _package_version(name: str) -> str | None: + try: + return version(name) + except PackageNotFoundError: + return None + + +def _execution_context() -> dict[str, Any]: + status = _git("status", "--porcelain") + return { + "git_commit": _git("rev-parse", "HEAD"), + "worktree_clean": status == "" if status is not None else None, + "source_fingerprint": _source_fingerprint(), + "platform": platform.platform(), + "machine": platform.machine(), + "python": platform.python_version(), + "packages": { + name: _package_version(name) + for name in ("cvxpy", "clarabel", "cyipopt", "numpy", "scipy") + }, + } + + +def _peak_rss_bytes() -> int: + raw = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss + return int(raw if sys.platform == "darwin" else raw * 1024) + + +def _strict_json_bytes(value: object) -> bytes: + return ( + json.dumps(value, sort_keys=True, separators=(",", ":"), allow_nan=False) + "\n" + ).encode() + + +def measure_point( + formulation: str, + horizon: int, + case_name: BaselineCase, + *, + observer: Callable[[str, dict[str, Any]], None] | None = None, + expected_commit: str | None = None, + expected_source_fingerprint: str | None = None, +) -> dict[str, Any]: + """Measure one point; callers isolate points in separate processes.""" + context_before = _execution_context() + if expected_commit is not None and context_before["git_commit"] != expected_commit: + raise RuntimeError("worker Git commit does not match parent context") + if ( + expected_source_fingerprint is not None + and context_before["source_fingerprint"] != expected_source_fingerprint + ): + raise RuntimeError("worker source fingerprint does not match parent context") + started = time.perf_counter() + fixture = build_baseline_fixture(formulation, horizon=horizon, case_name=case_name) + construction_seconds = time.perf_counter() - started + build = fixture.build + rss_after_construction = _peak_rss_bytes() + source = characterize_source_graph(build) + if observer is not None: + observer( + "construction", + { + "seconds": construction_seconds, + "peak_rss_bytes": rss_after_construction, + "source_structure": asdict(source), + }, + ) + + canonical = None + canonicalization_seconds = None + rss_after_canonicalization = None + if build.is_convex: + started = time.perf_counter() + canonical = characterize_convex_canonicalization(build, backend="CPP") + canonicalization_seconds = time.perf_counter() - started + rss_after_canonicalization = _peak_rss_bytes() + if observer is not None: + observer( + "canonicalization", + { + "seconds": canonicalization_seconds, + "peak_rss_bytes": rss_after_canonicalization, + "canonical_structure": asdict(canonical), + }, + ) + + started = time.perf_counter() + if build.is_convex: + build.solve(canon_backend=cp.CPP_CANON_BACKEND) + else: + build.solve() + solve_seconds = time.perf_counter() - started + rss_after_solve = _peak_rss_bytes() + if observer is not None: + observer( + "solve", + { + "seconds": solve_seconds, + "peak_rss_bytes": rss_after_solve, + "status": build.prob.status, + }, + ) + + started = time.perf_counter() + result = extract_results(build) + extraction_seconds = time.perf_counter() - started + rss_after_extraction = _peak_rss_bytes() + result_payload = json_result(result) + residuals = audit_result(fixture, result) + result_bytes = _strict_json_bytes(result_payload) + if observer is not None: + observer( + "extraction", + { + "seconds": extraction_seconds, + "peak_rss_bytes": rss_after_extraction, + "result_schema": result_schema(result), + "residuals": residuals, + "serialized_result_bytes": len(result_bytes), + }, + ) + context_after = _execution_context() + if ( + context_after["git_commit"] != context_before["git_commit"] + or context_after["source_fingerprint"] != context_before["source_fingerprint"] + ): + raise RuntimeError("execution source changed during worker measurement") + + return { + "schema_version": 1, + "execution_context": context_after, + "case": case_name, + "formulation": formulation, + "temporal_assembly": build.temporal_assembly, + "canonicalization_backend": ("CPP" if build.is_convex else "DNLP_IPOPT"), + "horizon": horizon, + "timing_seconds": { + "construction": construction_seconds, + "canonicalization": canonicalization_seconds, + "solve_after_explicit_canonicalization": solve_seconds, + "extraction": extraction_seconds, + }, + "peak_rss_bytes": { + "after_construction": rss_after_construction, + "after_canonicalization": rss_after_canonicalization, + "after_solve": rss_after_solve, + "after_extraction": rss_after_extraction, + }, + "source_structure": asdict(source), + "canonical_structure": None if canonical is None else asdict(canonical), + "result_schema": result_schema(result), + "residuals": residuals, + "result": result_payload, + "serialized_result_bytes": len(result_bytes), + "status": result["status"], + } + + +def _write_immutable(path: Path, payload: object) -> None: + _write_immutable_bytes(path, _strict_json_bytes(payload)) + + +def _write_immutable_bytes(path: Path, data: bytes) -> None: + flags = os.O_WRONLY | os.O_CREAT | os.O_EXCL + descriptor = os.open(path, flags, 0o644) + with os.fdopen(descriptor, "wb") as stream: + stream.write(data) + stream.flush() + os.fsync(stream.fileno()) + + +def _append_phase(path: Path, phase: str, payload: dict[str, Any]) -> None: + line = _strict_json_bytes({"phase": phase, **payload}) + with path.open("ab") as stream: + stream.write(line) + stream.flush() + os.fsync(stream.fileno()) + + +def _artifact_identity(path: Path) -> dict[str, Any]: + return { + "path": path.name, + "bytes": path.stat().st_size, + "sha256": _sha256(path), + } + + +def _validate_worker_artifact( + path: Path, + *, + formulation: str, + horizon: int, + case_name: str, + parent_context: dict[str, Any], +) -> dict[str, Any]: + payload = cast(dict[str, Any], json.loads(path.read_text())) + if payload["formulation"] != formulation: + raise ValueError("worker artifact formulation mismatch") + if int(payload["horizon"]) != horizon: + raise ValueError("worker artifact horizon mismatch") + if payload["case"] != case_name: + raise ValueError("worker artifact case mismatch") + context = payload["execution_context"] + for key in ("git_commit", "source_fingerprint"): + if context[key] != parent_context[key]: + raise ValueError(f"worker artifact {key} mismatch") + return payload + + +def _validate_phase_journal(path: Path, *, convex: bool) -> None: + records = [json.loads(line) for line in path.read_text().splitlines()] + expected = ["construction"] + if convex: + expected.append("canonicalization") + expected.extend(("solve", "extraction")) + if [record.get("phase") for record in records] != expected: + raise ValueError("worker phase journal is incomplete or out of order") + + +def _run_parent(args: argparse.Namespace) -> None: + output = args.output.resolve() + parent_context = _execution_context() + if not parent_context["git_commit"] or not parent_context["source_fingerprint"]: + raise RuntimeError("parent execution provenance is unavailable") + if not args.horizons or any(horizon <= 0 for horizon in args.horizons): + raise ValueError("horizons must contain positive integers") + if args.timeout_seconds <= 0: + raise ValueError("timeout_seconds must be positive") + output.mkdir(parents=True, exist_ok=False) + records: list[dict[str, Any]] = [] + for formulation in args.formulations: + for horizon in args.horizons: + destination = output / f"{formulation}-{horizon:05d}.json" + command = [ + sys.executable, + "-m", + "experiments.m14_time_vectorization.run_m14a", + "--worker", + "--formulation", + formulation, + "--horizon", + str(horizon), + "--case", + args.case, + "--output", + str(destination), + "--expected-commit", + str(parent_context["git_commit"]), + "--expected-source-fingerprint", + str(parent_context["source_fingerprint"]), + ] + classification = "completed" + try: + completed = subprocess.run( + command, + cwd=ROOT, + check=False, + capture_output=True, + timeout=args.timeout_seconds, + ) + returncode = completed.returncode + stdout = completed.stdout + stderr = completed.stderr + if returncode != 0: + classification = "worker_failure" + except subprocess.TimeoutExpired as error: + returncode = None + classification = "wall_time_limit" + stdout = error.stdout or b"" + stderr = error.stderr or b"" + log_path = destination.with_suffix(".log") + _write_immutable_bytes( + log_path, + b"--- stdout ---\n" + stdout + b"\n--- stderr ---\n" + stderr, + ) + artifact = None + if classification == "completed": + if not destination.exists(): + classification = "artifact_missing" + else: + try: + payload = _validate_worker_artifact( + destination, + formulation=formulation, + horizon=horizon, + case_name=args.case, + parent_context=parent_context, + ) + phase_path = destination.with_suffix(".phases.jsonl") + _validate_phase_journal(phase_path, convex=formulation != "ac") + except ( + FileNotFoundError, + KeyError, + TypeError, + ValueError, + json.JSONDecodeError, + ): + classification = "artifact_invalid" + else: + artifact = _artifact_identity(destination) + if payload["status"] not in { + cp.OPTIMAL, + cp.OPTIMAL_INACCURATE, + }: + classification = "solve_not_accepted" + evidence = {"log": _artifact_identity(log_path)} + phase_path = destination.with_suffix(".phases.jsonl") + if phase_path.exists(): + evidence["phases"] = _artifact_identity(phase_path) + if destination.exists() and artifact is None: + evidence["unvalidated_result"] = _artifact_identity(destination) + records.append( + { + "formulation": formulation, + "horizon": horizon, + "classification": classification, + "returncode": returncode, + "artifact": artifact, + "evidence": evidence, + } + ) + if classification != "completed": + break + _write_immutable( + output / "manifest.json", + { + "schema_version": 1, + "execution_context": parent_context, + "timeout_seconds_per_point": args.timeout_seconds, + "records": records, + }, + ) + + +def _parser() -> argparse.ArgumentParser: + parser = argparse.ArgumentParser() + parser.add_argument("--worker", action="store_true") + parser.add_argument("--formulation", choices=FORMULATIONS) + parser.add_argument("--horizon", type=int) + parser.add_argument("--case", choices=("case9", "case118"), default="case9") + parser.add_argument("--output", type=Path, required=True) + parser.add_argument( + "--formulations", nargs="+", choices=FORMULATIONS, default=FORMULATIONS + ) + parser.add_argument("--horizons", nargs="+", type=int, default=(1, 2, 4, 8)) + parser.add_argument("--timeout-seconds", type=float, default=1800.0) + parser.add_argument("--expected-commit") + parser.add_argument("--expected-source-fingerprint") + return parser + + +def main() -> None: + args = _parser().parse_args() + if args.worker: + if args.formulation is None or args.horizon is None: + raise SystemExit("worker requires --formulation and --horizon") + phase_path = args.output.resolve().with_suffix(".phases.jsonl") + _write_immutable_bytes(phase_path, b"") + record = measure_point( + args.formulation, + args.horizon, + args.case, + observer=lambda phase, payload: _append_phase(phase_path, phase, payload), + expected_commit=args.expected_commit, + expected_source_fingerprint=args.expected_source_fingerprint, + ) + _write_immutable(args.output.resolve(), record) + else: + _run_parent(args) + + +if __name__ == "__main__": + main() diff --git a/tests/test_m14a_baseline.py b/tests/test_m14a_baseline.py new file mode 100644 index 0000000..81c86b0 --- /dev/null +++ b/tests/test_m14a_baseline.py @@ -0,0 +1,311 @@ +"""M14a solved, failure, and scaling-record baselines.""" + +import hashlib +import json +from pathlib import Path +from types import SimpleNamespace +import warnings +from dataclasses import asdict +import subprocess + +import cvxpy as cp +import numpy as np +import pytest + +from cvxopf.results import extract_results +from cvxopf.characterization import ( + characterize_convex_canonicalization, + characterize_source_graph, +) +from experiments.m14_time_vectorization import run_m14a as runner +from experiments.m14_time_vectorization.baseline import ( + audit_result, + build_baseline_fixture, + json_result, + result_schema, +) +from experiments.m14_time_vectorization.run_m14a import ( + _run_parent, + _append_phase, + _sha256, + _validate_worker_artifact, + _write_immutable, + measure_point, +) + + +SCHEMA_DIGESTS = { + ("feasible", "ac"): ( + "95df1da0ca597f6a8c509c72dce458fd7c22bcea1b462f5bf67bb50efe093099" + ), + ("feasible", "lossy_dc"): ( + "68b9db7c84a45791839fee7810cad1a2cc1a93a55b2c92f3fa75cfb0be01d1f4" + ), + ("feasible", "singlenode_dc"): ( + "35840e680698e47e48d7736701e1b93690b3fae36b5f581d1fd587e6168d11ad" + ), + ("infeasible", "ac"): ( + "84f19de0ac9f06cbd74213a2545d64d85b0c34e9d4d9691891aa8bdab822b702" + ), + ("infeasible", "lossy_dc"): ( + "275c3414bc230d279d374b708da61894bbff6df9161da36eff42d014f4031101" + ), + ("infeasible", "singlenode_dc"): ( + "8fb04ccd9612d51ac3ee9314746defbea44991b2de8ae5d3006be2ad3c20b0ba" + ), +} + +FULL_SCHEMA_DIGESTS = { + "ac": "7260fc0fa5957f3e54d01ff3b2bac7dad7ae67f22450e4ae41f3c53c54b43d99", + "lossy_dc": ("bf47538be9cd141318b6da6f90bc9eaac161795bd8d2aa9490d6bd70a206269e"), + "singlenode_dc": ( + "5b91cdbb8dd1b7729ed87c89fc895b2a389e1358dd6ffa2a62c8f579d0672b88" + ), +} + +FULL_SOURCE_DIGESTS = { + "ac": "edeb22b142edc2342543e0c88aa2d7bf1040cc4549089bebb743fec3cd2ad42d", + "lossy_dc": ("de40a7a65ab125bbdd699f0daeccc6b2afcc88b9f08fdc9cda04b35d154cb661"), + "singlenode_dc": ( + "1da6f9ecc3880440b8d4f81b950d22b74807e5c6de9ff4275cd9eda67b2fdf1f" + ), +} + +FULL_CANONICAL_DIMENSIONS = { + "lossy_dc": (66, 31, 96, 127, 66, 218, 18), + "singlenode_dc": (22, 11, 34, 45, 22, 68, 6), +} + +EXPECTED_OBJECTIVES = { + "ac": 10593.258496096834, + "lossy_dc": 10432.130660908686, + "singlenode_dc": 10432.053215494549, +} + + +def _schema_digest(result: dict) -> str: + encoded = json.dumps( + result_schema(result), sort_keys=True, separators=(",", ":") + ).encode() + return hashlib.sha256(encoded).hexdigest() + + +@pytest.mark.parametrize("formulation", ["ac", "lossy_dc", "singlenode_dc"]) +def test_successful_fixture_retains_result_and_state_contract(formulation): + fixture = build_baseline_fixture(formulation) + fixture.build.solve() + result = extract_results(fixture.build) + + assert result["status"] in {cp.OPTIMAL, cp.OPTIMAL_INACCURATE} + assert _schema_digest(result) == SCHEMA_DIGESTS[("feasible", formulation)] + assert float(result["objective"]) == pytest.approx( + EXPECTED_OBJECTIVES[formulation], abs=2e-4 + ) + storage_power = np.asarray(result["b"], dtype=float) + state = np.asarray(result["soc"], dtype=float) + preceding = np.vstack(([50.0], state[:-1])) + np.testing.assert_allclose(state, preceding - storage_power, atol=2e-7) + np.testing.assert_allclose(state[-1], [50.0], atol=2e-7) + assert np.isfinite(float(result["storage_cost"])) + + +@pytest.mark.parametrize("formulation", ["ac", "lossy_dc", "singlenode_dc"]) +def test_unreachable_fixture_retains_real_infeasible_schema(formulation): + fixture = build_baseline_fixture(formulation, outcome="infeasible") + fixture.build.solve() + result = extract_results(fixture.build) + + assert result["status"] in {cp.INFEASIBLE, cp.INFEASIBLE_INACCURATE} + assert _schema_digest(result) == SCHEMA_DIGESTS[("infeasible", formulation)] + assert result["b"] is None + assert result["soc"] is None + assert np.isnan(float(result["objective"])) + assert json_result(result)["objective"] is None + + +@pytest.mark.parametrize("formulation", ["ac", "lossy_dc", "singlenode_dc"]) +def test_full_component_fixture_retains_schema_and_physical_audit(formulation): + fixture = build_baseline_fixture(formulation, components="full") + with warnings.catch_warnings(): + warnings.filterwarnings("ignore", message=".*not DPP.*") + fixture.build.solve() + result = extract_results(fixture.build) + + assert result["status"] in {cp.OPTIMAL, cp.OPTIMAL_INACCURATE} + assert _schema_digest(result) == FULL_SCHEMA_DIGESTS[formulation] + source = characterize_source_graph(fixture.build) + source_digest = hashlib.sha256( + json.dumps(asdict(source), sort_keys=True, separators=(",", ":")).encode() + ).hexdigest() + assert source_digest == FULL_SOURCE_DIGESTS[formulation] + if formulation != "ac": + canonical = characterize_convex_canonicalization(fixture.build) + assert ( + canonical.canonical_variable_count, + canonical.equality_rows, + canonical.nonnegative_rows, + canonical.coefficient_rows, + canonical.coefficient_columns, + canonical.coefficient_nonzeros, + canonical.quadratic_nonzeros, + ) == FULL_CANONICAL_DIMENSIONS[formulation] + residuals = audit_result(fixture, result) + assert residuals + assert max(residuals.values()) <= 1e-6 + assert "active_nodal_balance_mw_abs" in residuals + assert "active_load_service_mw_abs" in residuals + assert "curtailment_nonnegativity_mw_abs" in residuals + if formulation == "ac": + assert "reactive_nodal_balance_mvar_abs" in residuals + assert "voltage_bound_pu_abs" in residuals + assert "thermal_limit_mva_abs" in residuals + elif formulation == "lossy_dc": + assert "thermal_limit_mw_abs" in residuals + + +@pytest.mark.parametrize("formulation", ["lossy_dc", "singlenode_dc"]) +def test_measurement_record_separates_phases_and_dimensions(formulation): + record = measure_point(formulation, 1, "case9") + + assert record["status"] in {cp.OPTIMAL, cp.OPTIMAL_INACCURATE} + assert record["temporal_assembly"] == "stepwise" + assert record["canonicalization_backend"] == "CPP" + assert record["canonical_structure"] is not None + timing = record["timing_seconds"] + assert all(timing[name] >= 0 for name in timing) + memory = record["peak_rss_bytes"] + assert all(memory[name] > 0 for name in memory) + assert record["serialized_result_bytes"] > 0 + + +def test_ac_measurement_labels_dnlp_canonicalization_as_solve_owned(): + record = measure_point("ac", 1, "case9") + assert record["canonicalization_backend"] == "DNLP_IPOPT" + assert record["canonical_structure"] is None + assert record["timing_seconds"]["canonicalization"] is None + assert record["peak_rss_bytes"]["after_canonicalization"] is None + context = record["execution_context"] + assert len(context["source_fingerprint"]) == 64 + assert context["git_commit"] + assert context["packages"]["cvxpy"] + + +def test_artifact_writer_is_immutable(tmp_path: Path): + destination = tmp_path / "record.json" + _write_immutable(destination, {"value": 1}) + with pytest.raises(FileExistsError): + _write_immutable(destination, {"value": 2}) + assert json.loads(destination.read_text()) == {"value": 1} + + +def test_parent_manifest_hashes_isolated_worker_artifact(tmp_path: Path): + output = tmp_path / "run" + args = SimpleNamespace( + output=output, + formulations=["singlenode_dc"], + horizons=[1], + case="case9", + timeout_seconds=30.0, + ) + _run_parent(args) + + manifest = json.loads((output / "manifest.json").read_text()) + record = manifest["records"][0] + assert record["classification"] == "completed" + artifact = output / record["artifact"]["path"] + assert record["artifact"]["bytes"] == artifact.stat().st_size + assert record["artifact"]["sha256"] == _sha256(artifact) + phases = output / record["evidence"]["phases"]["path"] + assert record["evidence"]["phases"]["sha256"] == _sha256(phases) + assert [json.loads(line)["phase"] for line in phases.read_text().splitlines()] == [ + "construction", + "canonicalization", + "solve", + "extraction", + ] + + +def test_worker_artifact_validation_rejects_provenance_drift(tmp_path: Path): + destination = tmp_path / "worker.json" + destination.write_text( + json.dumps( + { + "formulation": "lossy_dc", + "horizon": 1, + "case": "case9", + "execution_context": { + "git_commit": "commit-a", + "source_fingerprint": "source-b", + }, + } + ) + ) + with pytest.raises(ValueError, match="source_fingerprint"): + _validate_worker_artifact( + destination, + formulation="lossy_dc", + horizon=1, + case_name="case9", + parent_context={ + "git_commit": "commit-a", + "source_fingerprint": "source-a", + }, + ) + + +def test_phase_journal_retains_construction_before_canonical_failure( + tmp_path: Path, monkeypatch +): + phase_path = tmp_path / "phases.jsonl" + phase_path.write_bytes(b"") + monkeypatch.setattr( + runner, + "characterize_convex_canonicalization", + lambda *_args, **_kwargs: (_ for _ in ()).throw( + RuntimeError("synthetic canonicalization failure") + ), + ) + with pytest.raises(RuntimeError, match="synthetic canonicalization"): + measure_point( + "lossy_dc", + 1, + "case9", + observer=lambda phase, payload: _append_phase(phase_path, phase, payload), + ) + records = [json.loads(line) for line in phase_path.read_text().splitlines()] + assert [record["phase"] for record in records] == ["construction"] + assert records[0]["source_structure"]["formulation"] == "lossy_dc" + + +def test_parent_rejects_zero_return_without_worker_artifact( + tmp_path: Path, monkeypatch +): + context = { + "git_commit": "commit", + "source_fingerprint": "source", + } + monkeypatch.setattr(runner, "_execution_context", lambda: context) + monkeypatch.setattr( + runner.subprocess, + "run", + lambda *_args, **_kwargs: subprocess.CompletedProcess( + args=[], returncode=0, stdout=b"", stderr=b"" + ), + ) + output = tmp_path / "missing" + _run_parent( + SimpleNamespace( + output=output, + formulations=["lossy_dc"], + horizons=[1], + case="case9", + timeout_seconds=30.0, + ) + ) + manifest = json.loads((output / "manifest.json").read_text()) + assert manifest["records"][0]["classification"] == "artifact_missing" + + +def test_infeasible_fixture_rejects_horizon_that_can_reach_target(): + with pytest.raises(ValueError, match="horizon < 100"): + build_baseline_fixture("lossy_dc", horizon=100, outcome="infeasible") From 57ae24f46b9bdb3afbd204d5d51d3239b0159624 Mon Sep 17 00:00:00 2001 From: Bennet Meyers Date: Tue, 25 Aug 2026 22:00:25 -0700 Subject: [PATCH 06/28] docs: refine project update presentation --- .../cvxopf_project_update.tex | 99 +++++++---- .../weekly_update_20260826/make_figures.py | 162 +++++++++++++++--- 2 files changed, 199 insertions(+), 62 deletions(-) diff --git a/presentations/weekly_update_20260826/cvxopf_project_update.tex b/presentations/weekly_update_20260826/cvxopf_project_update.tex index 7d5a3ab..cad1633 100644 --- a/presentations/weekly_update_20260826/cvxopf_project_update.tex +++ b/presentations/weekly_update_20260826/cvxopf_project_update.tex @@ -75,25 +75,32 @@ \end{columns} \end{frame} -\begin{frame}{A common modeling system now spans the research questions} - \small - \begin{center} - \begin{tikzpicture}[scale=0.82,transform shape,node distance=6mm and 8mm, +\begin{frame}{Device physics are defined once and reused across fidelity levels} + \centering + \large A shared component model makes DC planning and AC realization parts of + \textbf{one mathematical system}. + \normalsize + \vspace{0.5em} + + \begin{tikzpicture}[scale=0.84,transform shape,node distance=5mm and 8mm, box/.style={draw=customblue,rounded corners,fill=customblue!7,minimum height=9mm,align=center}, + form/.style={draw=mutedgreen,rounded corners,fill=mutedgreen!7,minimum width=28mm,minimum height=9mm,align=center}, arr/.style={-{Latex[length=2mm]},thick,customblue}] - \node[box] (data) {network + profiles\\\scriptsize stable device identity}; - \node[box,right=of data] (components) {component models\\\scriptsize generators, renewables, storage, loads, HVDC}; - \node[box,right=of components] (assembly) {typed assembly\\\scriptsize variables, injections, constraints, costs}; - \node[box,below=of assembly] (forms) {formulations\\\scriptsize AC, lossy DC, single-node DC}; - \node[box,left=of forms] (solve) {solve + audit\\\scriptsize stable results and residual gates}; - \node[box,left=of solve] (hier) {hierarchical control\\\scriptsize signposts, feedback, recovery}; + \node[box] (data) {network + profiles\\\scriptsize identity-aligned inputs}; + \node[box,right=of data] (components) {component-owned mathematics\\\scriptsize variables, injections, constraints, costs}; + \node[box,right=of components] (assembly) {generic typed assembly\\\scriptsize common horizon and result contracts}; + \node[form,below left=7mm and 23mm of assembly] (ac) {nonlinear AC}; + \node[form,right=6mm of ac] (dc) {lossy DC}; + \node[form,right=6mm of dc] (single) {single-node DC}; + \node[box,below=8mm of dc] (hier) {hierarchical studies\\\scriptsize state constraints passed between fidelity levels}; \draw[arr] (data)--(components); \draw[arr] (components)--(assembly); - \draw[arr] (assembly)--(forms); \draw[arr] (forms)--(solve); \draw[arr] (solve)--(hier); + \draw[arr] (assembly)--(ac); \draw[arr] (assembly)--(dc); \draw[arr] (assembly)--(single); + \draw[arr] (ac)--(hier); \draw[arr] (dc)--(hier); \draw[arr] (single)--(hier); \end{tikzpicture} - \end{center} - \begin{itemize} - \item Components contribute their own mathematics through a typed contract. - \item Formulation builders aggregate those contributions generically, so storage, load, and network semantics survive across layers. + \vspace{0.45em} + \begin{itemize}\tightitems + \item Formulation builders supply network equations; components retain the same identities, operating semantics, and costs in every formulation. + \item Demonstrated: lossy-DC SoC signposts coordinate AC realization. Proposed: a single-node layer could pass an aggregate storage-energy equality into a networked lossy-DC layer. \end{itemize} \end{frame} @@ -164,31 +171,55 @@ \end{itemize} \end{frame} -\begin{frame}{The hierarchical controller closes the loop} - \centering - \begin{tikzpicture}[node distance=8mm and 12mm, - box/.style={draw=customblue,rounded corners,fill=customblue!7,minimum width=31mm,minimum height=13mm,align=center}, - arr/.style={-{Latex[length=2.5mm]},very thick,customblue}] - \node[box] (outer) {long-horizon DC\\\scriptsize feasible SoC signposts}; - \node[box,right=of outer] (window) {short AC window\\\scriptsize hard/soft endpoint}; - \node[box,right=of window] (action) {accept first action\\\scriptsize audited AC dispatch}; - \node[box,below=of window] (state) {realized state feedback\\\scriptsize SoC + causal warm start}; - \draw[arr] (outer)--(window); \draw[arr] (window)--(action); - \draw[arr] (action)|-(state); \draw[arr] (state)-|(outer); - \end{tikzpicture} - \vspace{1em} +\begin{frame}{Two hierarchical paradigms share the same AC realization} + \begin{columns}[T,onlytextwidth] + \column{0.48\textwidth} + \centering + \textbf{Frozen outer plan} + \vspace{0.35em} + + \begin{tikzpicture}[node distance=4.5mm, + box/.style={draw=customblue,rounded corners,fill=customblue!7,minimum width=39mm,minimum height=9mm,align=center}, + arr/.style={-{Latex[length=2.2mm]},thick,customblue}] + \node[box] (outerf) {solve long-horizon DC once}; + \node[box,below=of outerf] (signf) {fixed SoC signpost sequence}; + \node[box,below=of signf] (acf) {solve next AC window}; + \node[box,below=of acf] (statef) {execute first action\\\scriptsize carry realized SoC forward}; + \draw[arr] (outerf)--(signf); \draw[arr] (signf)--(acf); + \draw[arr] (acf)--(statef); + \draw[arr] (statef.east) -- ++(7mm,0) |- (acf.east); + \end{tikzpicture} + + \column{0.48\textwidth} + \centering + \textbf{Closed-loop outer replanning} + \vspace{0.35em} + + \begin{tikzpicture}[node distance=4.5mm, + box/.style={draw=mutedgreen,rounded corners,fill=mutedgreen!7,minimum width=39mm,minimum height=9mm,align=center}, + arr/.style={-{Latex[length=2.2mm]},thick,mutedgreen}] + \node[box] (outerr) {solve remaining-horizon DC}; + \node[box,below=of outerr] (signr) {select next SoC signpost}; + \node[box,below=of signr] (acr) {solve next AC window}; + \node[box,below=of acr] (stater) {execute first action\\\scriptsize observe realized SoC}; + \draw[arr] (outerr)--(signr); \draw[arr] (signr)--(acr); + \draw[arr] (acr)--(stater); + \draw[arr] (stater.east) -- ++(7mm,0) |- (outerr.east); + \end{tikzpicture} + \end{columns} + \vspace{0.6em} \begin{itemize}\tightitems - \item The outer model maintains the energy plan; the inner model realizes the next action with AC voltage, reactive-power, loss, and thermal physics. - \item Realized state—not an imagined DC action—feeds the next decision. + \item Both use audited AC actions and realized-state handoff; replanning additionally updates the outer trajectory from realized state and new information. + \item The 96-hour study shows that continuous outer replanning is available, but not always necessary: a coherent frozen plan can remain AC-realizable. \end{itemize} \end{frame} -\begin{frame}{The first 96-hour study exposed two different failure mechanisms} +\begin{frame}{The 96-hour study validated hierarchical control} \centering - \includegraphics[width=0.92\textwidth,height=0.55\textheight,keepaspectratio]{m17_policy_outcomes.pdf} + \includegraphics[width=0.96\textwidth,height=0.58\textheight,keepaspectratio]{m17_soc_trajectories.pdf} \begin{itemize}\tightitems - \item \textbf{Numerical/local-solver sensitivity:} flat-start IPOPT reported infeasible at one hard-target window; six alternate starts solved the identical problem. - \item \textbf{Genuine loss of terminal viability:} soft deviations left 128.1 MW required charging in the last hour, but only 123.6 MW aggregate headroom. + \item \textbf{Hard targets:} both the frozen and repeatedly replanned controllers track the initial DC energy trajectory closely while realizing it through AC-feasible actions. + \item \textbf{Soft targets:} both controllers diverge as expected when the configured penalty favors operating flexibility over exact signpost agreement; a consistent soft policy would also soften and solve the final endpoint. \end{itemize} \end{frame} diff --git a/presentations/weekly_update_20260826/make_figures.py b/presentations/weekly_update_20260826/make_figures.py index d43de0a..1e79cd9 100644 --- a/presentations/weekly_update_20260826/make_figures.py +++ b/presentations/weekly_update_20260826/make_figures.py @@ -2,6 +2,7 @@ from __future__ import annotations +import gzip import json from pathlib import Path @@ -17,12 +18,20 @@ ROOT / "experiments/hierarchical_battery_resilience/results/s3_authoritative_0cd65b1" ) +M17B = ( + ROOT + / "experiments/hierarchical_battery_resilience/results/s3b_causal_recovery" +) CASE118 = ROOT / "experiments/case118_annual_hierarchy" -BLUE = "#214796" -ORANGE = "#e0521f" -GREEN = "#198c59" -GRAY = "#777777" +# Okabe-Ito colorblind-friendly palette. Important comparisons also use +# distinct line styles so that color is never the only visual encoding. +BLUE = "#0072B2" +SKY = "#56B4E9" +ORANGE = "#E69F00" +GREEN = "#009E73" +VERMILLION = "#D55E00" +GRAY = "#6F6F6F" def finish(fig: plt.Figure, name: str) -> None: @@ -111,24 +120,55 @@ def formulation_results() -> None: fig, axes = plt.subplots( 1, 2, figsize=(10.8, 4.0), gridspec_kw={"width_ratios": [1.15, 1]} ) - cases = ["case9\nsparse", "case57\nsparse", "case9\ndense", "case57\ndense"] - ratios = [3.2, 27.2, 4.0, 110.1] - bars = axes[0].bar(cases, ratios, color=[GREEN, GREEN, ORANGE, ORANGE]) - axes[0].bar_label(bars, fmt="%.1f×", padding=3) + case_labels = ["case9", "case57"] + sparse_ratios = [3.2, 27.2] + dense_ratios = [4.0, 110.1] + case_x = np.arange(len(case_labels)) + width = 0.34 + sparse_bars = axes[0].bar( + case_x - width / 2, + sparse_ratios, + width, + label="sparse P/Q", + color=BLUE, + ) + dense_bars = axes[0].bar( + case_x + width / 2, + dense_ratios, + width, + label="dense P/Q", + color=ORANGE, + ) + axes[0].bar_label(sparse_bars, fmt="%.1f×", padding=3) + axes[0].bar_label(dense_bars, fmt="%.1f×", padding=3) + axes[0].set_xticks(case_x, case_labels) axes[0].set_yscale("log") axes[0].set_ylabel("Direct / lifted solve time") axes[0].set_title( "Equivalent lifted branch limits solve much faster", fontweight="bold" ) axes[0].grid(axis="y", alpha=0.25) + axes[0].legend(frameon=False) metrics = ["variables", "equalities", "inequalities"] direct = [668, 655, 188] lifted = [988, 975, 188] x = np.arange(3) - width = 0.36 - axes[1].bar(x - width / 2, direct, width, label="direct", color=GRAY) - axes[1].bar(x + width / 2, lifted, width, label="lifted", color=BLUE) + comparison_width = 0.36 + axes[1].bar( + x - comparison_width / 2, + direct, + comparison_width, + label="direct", + color=GRAY, + ) + axes[1].bar( + x + comparison_width / 2, + lifted, + comparison_width, + label="lifted", + color=BLUE, + ) axes[1].set_xticks(x, metrics) axes[1].set_ylabel("Scalar model entries (case57 sparse)") axes[1].set_title( @@ -139,26 +179,92 @@ def formulation_results() -> None: finish(fig, "formulation_results.pdf") -def m17_outcomes() -> None: - data = pd.read_csv(M17 / "trajectory_summary.csv") - labels = ["frozen / hard", "frozen / soft", "replanned / hard", "replanned / soft"] - colors = [GREEN, BLUE, ORANGE, ORANGE] - fig, ax = plt.subplots(figsize=(9.8, 3.8)) - bars = ax.barh(labels, data["completed_intervals"], color=colors) - ax.axvline(96, color="black", linewidth=1) - for bar, completed in zip(bars, data["completed"], strict=True): - text = "complete" if completed else "stopped" - ax.text( - bar.get_width() + 1, bar.get_y() + bar.get_height() / 2, text, va="center" +def _load_gzip_json(path: Path) -> dict[str, object]: + with gzip.open(path, "rt", encoding="utf-8") as stream: + return json.load(stream) + + +def m17_soc_trajectories() -> None: + frozen_hard = _load_gzip_json(M17 / "frozen__hard_equality.json.gz") + frozen_soft = _load_gzip_json(M17 / "frozen__quadratic_soft.json.gz") + replanned_soft = _load_gzip_json( + M17 / "replan_every_step__quadratic_soft.json.gz" + ) + replanned_hard = _load_gzip_json(M17B / "causal_recovery.json.gz") + + outer_plan = next(iter(frozen_hard["outer_plans"].values())) + trajectories = ( + ( + "initial DC energy plan", + outer_plan["boundary_soc_mwh"], + "black", + "--", + 2.2, + ), + ("frozen / hard", frozen_hard["realized_soc_mwh"], BLUE, "-", 1.8), + ("frozen / soft", frozen_soft["realized_soc_mwh"], SKY, "-.", 1.8), + ( + "replanned / hard + recovery", + replanned_hard["realized_soc_mwh"], + GREEN, + ":", + 1.6, + ), + ( + "replanned / soft", + replanned_soft["realized_soc_mwh"], + VERMILLION, + "-", + 1.8, + ), + ) + + fig, ax = plt.subplots(figsize=(10.4, 4.2)) + for label, raw_values, color, linestyle, linewidth in trajectories: + values = np.asarray(raw_values, dtype=float)[:, 0] + boundaries = np.arange(values.size) + ax.plot( + boundaries, + values, + color=color, + linestyle=linestyle, + linewidth=linewidth, + label=label, ) - ax.set(xlim=(0, 108), xlabel="Accepted executed intervals (of 96)") + + soft_values = np.asarray(replanned_soft["realized_soc_mwh"], dtype=float)[:, 0] + ax.scatter( + [soft_values.size - 1], + [soft_values[-1]], + marker="x", + s=55, + linewidth=2, + color=VERMILLION, + zorder=5, + ) + ax.annotate( + "mixed-policy baseline stopped\nbefore the final soft solve", + xy=(soft_values.size - 1, soft_values[-1]), + xytext=(-7, -35), + textcoords="offset points", + ha="right", + fontsize=8.5, + color=VERMILLION, + arrowprops={"arrowstyle": "-", "color": VERMILLION, "linewidth": 0.8}, + ) + ax.set( + xlim=(0, 96), + ylim=(0, 1025), + xlabel="Global boundary (hour)", + ylabel="Battery SoC (MWh)", + ) ax.set_title( - "Hard obligations complete; soft deviation can lose terminal viability", + "AC realization follows the energy plan while soft targets preserve flexibility", fontweight="bold", ) - ax.grid(axis="x", alpha=0.25) - ax.invert_yaxis() - finish(fig, "m17_policy_outcomes.pdf") + ax.grid(alpha=0.2) + ax.legend(frameon=False, ncols=3, loc="upper center", fontsize=8.5) + finish(fig, "m17_soc_trajectories.pdf") def recycling() -> None: @@ -201,7 +307,7 @@ def main() -> None: terminal_value() locality_and_handoff() formulation_results() - m17_outcomes() + m17_soc_trajectories() recycling() From f7ea5471fd5fb1b06a835b01fa4782ccb4727dde Mon Sep 17 00:00:00 2001 From: Bennet Meyers Date: Tue, 25 Aug 2026 22:01:54 -0700 Subject: [PATCH 07/28] feat: add M14a legacy scaling and promotion gate Freeze the formulation-specific legacy scaling ladders and add independent reconstruction of structural, numerical, performance, and provenance evidence. Require matched execution environments, clean analysis provenance, and consistent worker classifications before promoting the consolidated M14a baseline. --- experiments/m14_time_vectorization/.gitignore | 1 + .../m14_time_vectorization/M14A_PROTOCOL.md | 56 ++ .../m14_time_vectorization/baseline.py | 65 ++- .../m14_time_vectorization/m14a_analysis.py | 492 ++++++++++++++++++ .../m14_time_vectorization/run_m14a.py | 236 +++++---- tests/test_m14a_analysis.py | 277 ++++++++++ 6 files changed, 1026 insertions(+), 101 deletions(-) create mode 100644 experiments/m14_time_vectorization/.gitignore create mode 100644 experiments/m14_time_vectorization/m14a_analysis.py create mode 100644 tests/test_m14a_analysis.py diff --git a/experiments/m14_time_vectorization/.gitignore b/experiments/m14_time_vectorization/.gitignore new file mode 100644 index 0000000..fbca225 --- /dev/null +++ b/experiments/m14_time_vectorization/.gitignore @@ -0,0 +1 @@ +results/ diff --git a/experiments/m14_time_vectorization/M14A_PROTOCOL.md b/experiments/m14_time_vectorization/M14A_PROTOCOL.md index 7ccf1b6..d80c097 100644 --- a/experiments/m14_time_vectorization/M14A_PROTOCOL.md +++ b/experiments/m14_time_vectorization/M14A_PROTOCOL.md @@ -34,3 +34,59 @@ Scaling stops after the first unsuccessful or timed-out worker for each formulation and preserves that classification in the immutable manifest. The default per-point wall limit is 1,800 seconds and authoritative runs must record any reviewed override. + +The frozen legacy ladders are formulation-specific: + +- Case9 AC: 1, 2, 4, 8, and 24 steps. +- Case9 lossy DC and single-node DC: 1, 2, 4, 8, 24, and 168 steps. +- Case118 AC: 1 and 3 steps. +- Case118 lossy DC: 24, 168, and 720 steps. +- Case118 single-node DC: 24, 168, 720, and 8,760 steps. + +The bounded AC ladder is characterization, not an annual-AC feasibility +claim. The Case118 lossy-DC ladder stops at 720 because the already retained +failed annual S4 attempts supply the 8,760-step legacy resource-boundary +evidence; M14a does not repeat that expensive failure. The single-node path +retains 8,760 because its smaller per-step network graph is a useful annual +legacy comparator. + +Independent analysis re-verifies every manifest artifact identity, execution +fingerprint, point ordering, assembly/backend choice, accepted status, result +schema, and physical residual gate. Workers retain the minimal numerical audit +inputs, allowing analysis to reconstruct the residuals without rebuilding the +large legacy CVXPY graph. Each ladder is a separately retained +record; neither alone authorizes advancement. The consolidated M14a result +requires both complete ladders from the same commit and source fingerprint. +The two executions must also share platform, architecture, Python, package, +and underlying IPOPT-library versions so their timing and memory observations +form one comparable baseline. The compact result retains readable source and +canonical structures, objectives and component-cost scalars, artifact sizes, +and their corresponding digests; ignored raw artifacts are not required to +interpret the baseline. +Authoritative advancement and promotion additionally require clean parent and +worker provenance plus a clean analyzer from that exact execution commit and +source fingerprint. A numerically complete dirty-worktree run remains evidence +but is not the frozen M14a record. Worker return codes, classifications, and +artifact availability must also match the frozen supervisor outcome matrix. +An unsuccessful point and the intentionally omitted later points remain valid +partial characterization evidence but cannot be labeled a complete M14a +baseline or authorize M14b advancement. + +From a clean committed tree, the authoritative execution and consolidation +commands are: + +```bash +uv run python -m experiments.m14_time_vectorization.run_m14a \ + --frozen-ladder case9 \ + --output experiments/m14_time_vectorization/results/m14a-case9 +uv run python -m experiments.m14_time_vectorization.run_m14a \ + --frozen-ladder case118 \ + --output experiments/m14_time_vectorization/results/m14a-case118 +uv run python -m experiments.m14_time_vectorization.m14a_analysis \ + experiments/m14_time_vectorization/results/m14a-case9 \ + experiments/m14_time_vectorization/results/m14a-case118 \ + --promote experiments/m14_time_vectorization/M14A_RESULTS.json +``` + +Raw worker artifacts remain ignored under `results/`; the independently +reconstructed compact result is the tracked scientific record. diff --git a/experiments/m14_time_vectorization/baseline.py b/experiments/m14_time_vectorization/baseline.py index c7cbb65..e4bad01 100644 --- a/experiments/m14_time_vectorization/baseline.py +++ b/experiments/m14_time_vectorization/baseline.py @@ -201,10 +201,53 @@ def _maximum_violation( ) -def audit_result(fixture: BaselineFixture, result: dict[str, Any]) -> dict[str, float]: - """Independently reconstruct common and formulation-specific residuals.""" - build = fixture.build - data = build.data +def audit_inputs(fixture: BaselineFixture) -> dict[str, Any]: + """Retain only the numerical inputs needed to reconstruct the audit.""" + data = fixture.build.data + names = ( + "baseMVA", + "Cg", + "Cs", + "Cload", + "Cnd", + "Ch_from", + "Ch_to", + "Pgmin", + "Pgmax", + "Qgmin", + "Qgmax", + "storage_initial_soc", + "storage_delta", + "storage_capacity", + "storage_terminal_soc", + "storage_apparent_power_rating", + "sheddable_load_indices", + "load_max_shed_fraction", + "nd_available", + "nd_apparent_power_rating", + "branch_rate_a_mva", + "f_max", + "r", + ) + retained: dict[str, Any] = {} + for name in names: + if name not in data: + continue + value = data[name] + if np.isscalar(value): + retained[name] = float(value) + else: + retained[name] = np.asarray(value).tolist() + ppc = _case(fixture.case_name) + retained["voltage_min"] = ppc["bus"][:, 12].tolist() + retained["voltage_max"] = ppc["bus"][:, 11].tolist() + return retained + + +def audit_result_from_inputs( + formulation: str, data: dict[str, Any], result: dict[str, Any] +) -> dict[str, float]: + """Independently reconstruct residuals from retained numerical inputs.""" base = float(data["baseMVA"]) generation = np.asarray(result["Pg"], dtype=float) storage_power = np.asarray(result["b"], dtype=float) @@ -300,7 +343,7 @@ def audit_result(fixture: BaselineFixture, result: dict[str, Any]) -> dict[str, np.max(np.abs(hvdc_out + 0.99 * hvdc_in)) ) - if fixture.formulation == "ac": + if formulation == "ac": reactive = ( np.asarray(result["Qg"], dtype=float) @ np.asarray(data["Cg"], dtype=float).T @@ -339,10 +382,11 @@ def audit_result(fixture: BaselineFixture, result: dict[str, Any]) -> dict[str, base * np.asarray(data["Qgmin"]), base * np.asarray(data["Qgmax"]), ) - ppc = _case(fixture.case_name) voltage = np.asarray(result["Vm"], dtype=float) residuals["voltage_bound_pu_abs"] = _maximum_violation( - voltage, ppc["bus"][:, 12], ppc["bus"][:, 11] + voltage, + np.asarray(data["voltage_min"], dtype=float), + np.asarray(data["voltage_max"], dtype=float), ) branch_limit = np.asarray(data["branch_rate_a_mva"], dtype=float) branch_magnitude = np.maximum( @@ -358,7 +402,7 @@ def audit_result(fixture: BaselineFixture, result: dict[str, Any]) -> dict[str, residuals["branch_loss_nonnegativity_mw_abs"] = float( max(0.0, -np.min(branch_loss)) ) - elif fixture.formulation == "lossy_dc": + elif formulation == "lossy_dc": residuals["thermal_limit_mw_abs"] = _maximum_violation( np.asarray(result["p_flows"], dtype=float), -base * np.asarray(data["f_max"]), @@ -370,3 +414,8 @@ def audit_result(fixture: BaselineFixture, result: dict[str, Any]) -> dict[str, ) residuals["dc_loss_nonnegativity_abs"] = float(max(0.0, -np.min(dc_loss))) return residuals + + +def audit_result(fixture: BaselineFixture, result: dict[str, Any]) -> dict[str, float]: + """Independently reconstruct common and formulation-specific residuals.""" + return audit_result_from_inputs(fixture.formulation, audit_inputs(fixture), result) diff --git a/experiments/m14_time_vectorization/m14a_analysis.py b/experiments/m14_time_vectorization/m14a_analysis.py new file mode 100644 index 0000000..b191cf1 --- /dev/null +++ b/experiments/m14_time_vectorization/m14a_analysis.py @@ -0,0 +1,492 @@ +"""Independent reconstruction and compact promotion of an M14a legacy run.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import os +from pathlib import Path +import subprocess +from typing import Any, cast + +import cvxpy as cp +import numpy as np + +from experiments.m14_time_vectorization.baseline import ( + audit_result_from_inputs, + result_schema, +) +from experiments.m14_time_vectorization.run_m14a import ( + FROZEN_LADDERS, + ROOT, + _validate_phase_journal, +) + + +AUDIT_TOLERANCE = 1e-5 +CLASSIFICATIONS = { + "completed", + "worker_failure", + "wall_time_limit", + "artifact_missing", + "artifact_invalid", + "solve_not_accepted", +} +ENVIRONMENT_FIELDS = ("platform", "machine", "python", "packages") +ANALYSIS_SOURCES = tuple( + sorted((ROOT / "src" / "cvxopf").rglob("*.py")) + + sorted((ROOT / "experiments" / "m14_time_vectorization").rglob("*.py")) +) + + +def _sha256(path: Path) -> str: + digest = hashlib.sha256() + with path.open("rb") as stream: + for block in iter(lambda: stream.read(1024 * 1024), b""): + digest.update(block) + return digest.hexdigest() + + +def _digest(value: object) -> str: + encoded = json.dumps(value, sort_keys=True, separators=(",", ":")).encode() + return hashlib.sha256(encoded).hexdigest() + + +def _analysis_source_fingerprint() -> str: + digest = hashlib.sha256() + for path in sorted(ANALYSIS_SOURCES): + digest.update(path.relative_to(ROOT).as_posix().encode()) + digest.update(b"\0") + digest.update(path.read_bytes()) + digest.update(b"\0") + return digest.hexdigest() + + +def _git(*arguments: str) -> str | None: + completed = subprocess.run( + ["git", *arguments], cwd=ROOT, check=False, capture_output=True, text=True + ) + return completed.stdout.strip() if completed.returncode == 0 else None + + +def _confined_artifact(directory: Path, relative: object) -> Path: + if not isinstance(relative, str) or not relative: + raise ValueError("artifact path must be a nonempty relative string") + candidate = Path(relative) + if candidate.is_absolute() or candidate != Path(*candidate.parts): + raise ValueError("artifact path must be normalized and relative") + resolved = (directory / candidate).resolve() + if resolved.parent != directory.resolve(): + raise ValueError("artifact path escapes the run directory") + return resolved + + +def _verified_identity(directory: Path, identity: object) -> Path: + if not isinstance(identity, dict): + raise ValueError("artifact identity must be a mapping") + path = _confined_artifact(directory, identity.get("path")) + if not path.is_file(): + raise ValueError("retained artifact is missing") + if path.stat().st_size != identity.get("bytes"): + raise ValueError("retained artifact size mismatch") + if _sha256(path) != identity.get("sha256"): + raise ValueError("retained artifact hash mismatch") + return path + + +def _expected_points(ladder: str) -> list[tuple[str, int, str]]: + return list(FROZEN_LADDERS[ladder]) + + +def _required_int(value: object, name: str) -> int: + if not isinstance(value, int) or isinstance(value, bool): + raise ValueError(f"{name} must be an integer") + return value + + +def _finite_nonnegative(value: object, name: str) -> float: + if not isinstance(value, (int, float)) or isinstance(value, bool): + raise ValueError(f"{name} must be numeric") + numeric = float(value) + if not np.isfinite(numeric) or numeric < 0: + raise ValueError(f"{name} must be finite and nonnegative") + return numeric + + +def _validate_measurements(payload: dict[str, Any], formulation: str) -> None: + timing = payload.get("timing_seconds") + memory = payload.get("peak_rss_bytes") + if not isinstance(timing, dict) or not isinstance(memory, dict): + raise ValueError("worker timing or memory evidence is missing") + for name in ("construction", "solve_after_explicit_canonicalization", "extraction"): + _finite_nonnegative(timing.get(name), f"{name} timing") + for name in ("after_construction", "after_solve", "after_extraction"): + if _finite_nonnegative(memory.get(name), f"{name} RSS") <= 0: + raise ValueError(f"{name} RSS must be positive") + if formulation == "ac": + if timing.get("canonicalization") is not None: + raise ValueError("AC canonicalization timing must be solve-owned") + if memory.get("after_canonicalization") is not None: + raise ValueError("AC canonicalization RSS must be solve-owned") + if payload.get("canonical_structure") is not None: + raise ValueError("AC must not retain convex canonical structure") + else: + _finite_nonnegative(timing.get("canonicalization"), "canonicalization timing") + if ( + _finite_nonnegative( + memory.get("after_canonicalization"), "after_canonicalization RSS" + ) + <= 0 + ): + raise ValueError("after_canonicalization RSS must be positive") + if not isinstance(payload.get("canonical_structure"), dict): + raise ValueError("convex canonical structure is missing") + if not isinstance(payload.get("source_structure"), dict): + raise ValueError("source structure is missing") + + +def _validate_classification_record(record: dict[str, Any]) -> None: + classification = record.get("classification") + returncode = record.get("returncode") + artifact = record.get("artifact") + evidence = record.get("evidence") + if not isinstance(evidence, dict): + raise ValueError("manifest evidence must be a mapping") + unvalidated = evidence.get("unvalidated_result") + if classification == "completed": + valid = returncode == 0 and artifact is not None and unvalidated is None + elif classification == "worker_failure": + valid = ( + isinstance(returncode, int) + and not isinstance(returncode, bool) + and returncode != 0 + and artifact is None + ) + elif classification == "wall_time_limit": + valid = returncode is None and artifact is None + elif classification == "artifact_missing": + valid = returncode == 0 and artifact is None and unvalidated is None + elif classification == "artifact_invalid": + valid = returncode == 0 and artifact is None + elif classification == "solve_not_accepted": + valid = returncode == 0 and artifact is not None and unvalidated is None + else: + raise ValueError("unknown M14a worker classification") + if not valid: + raise ValueError("worker classification evidence is inconsistent") + + +def _serialized_schema_matches( + serialized_result: dict[str, Any], retained_schema: object +) -> bool: + """Compare schemas while allowing JSON to normalize object string arrays.""" + if not isinstance(retained_schema, dict): + return False + reconstructed = result_schema(serialized_result) + if reconstructed.keys() != retained_schema.keys(): + return False + for name, actual in reconstructed.items(): + expected = retained_schema[name] + if not isinstance(expected, dict): + return False + if actual == expected: + continue + normalized_actual = dict(actual) + normalized_expected = dict(expected) + if { + normalized_actual.get("dtype_kind"), + normalized_expected.get("dtype_kind"), + } <= {"O", "U"}: + normalized_actual.pop("dtype_kind", None) + normalized_expected.pop("dtype_kind", None) + if normalized_actual != normalized_expected: + return False + return True + + +def analyze_run(directory: Path) -> dict[str, Any]: + """Validate retained evidence and return a compact scientific record.""" + root = directory.resolve() + manifest_path = root / "manifest.json" + manifest = cast(dict[str, Any], json.loads(manifest_path.read_text())) + if manifest.get("schema_version") != 1: + raise ValueError("unsupported M14a manifest schema") + if ( + _finite_nonnegative( + manifest.get("timeout_seconds_per_point"), "per-point timeout" + ) + <= 0 + ): + raise ValueError("per-point timeout must be positive") + ladder = manifest.get("frozen_ladder") + if ladder not in FROZEN_LADDERS: + raise ValueError("manifest does not identify a frozen M14a ladder") + records = manifest.get("records") + if not isinstance(records, list) or not records: + raise ValueError("manifest records must be a nonempty list") + context = manifest.get("execution_context") + if not isinstance(context, dict): + raise ValueError("manifest execution context is missing") + + expected = _expected_points(str(ladder)) + expected_index = 0 + stopped: set[str] = set() + summaries: list[dict[str, Any]] = [] + complete = True + provenance_clean = context.get("worktree_clean") is True + for raw_record in records: + if not isinstance(raw_record, dict): + raise ValueError("manifest record must be a mapping") + formulation = str(raw_record.get("formulation")) + horizon = _required_int(raw_record.get("horizon"), "manifest horizon") + case_name = str(raw_record.get("case")) + while expected_index < len(expected) and expected[expected_index][0] in stopped: + expected_index += 1 + if expected_index >= len(expected) or expected[expected_index] != ( + formulation, + horizon, + case_name, + ): + raise ValueError("manifest point order does not match frozen ladder") + expected_index += 1 + classification = str(raw_record.get("classification")) + if classification not in CLASSIFICATIONS: + raise ValueError("unknown M14a worker classification") + evidence = raw_record.get("evidence") + if not isinstance(evidence, dict): + raise ValueError("manifest evidence must be a mapping") + _validate_classification_record(raw_record) + log_path = _verified_identity(root, evidence.get("log")) + phases_identity = evidence.get("phases") + phase_path = ( + None + if phases_identity is None + else _verified_identity(root, phases_identity) + ) + summary: dict[str, Any] = { + "case": case_name, + "formulation": formulation, + "horizon": horizon, + "classification": classification, + "returncode": raw_record.get("returncode"), + "log_sha256": _sha256(log_path), + "phase_journal_sha256": ( + None if phase_path is None else _sha256(phase_path) + ), + } + if classification != "completed": + complete = False + stopped.add(formulation) + retained_result = None + if raw_record.get("artifact") is not None: + retained_result = _verified_identity(root, raw_record.get("artifact")) + elif evidence.get("unvalidated_result") is not None: + retained_result = _verified_identity( + root, evidence.get("unvalidated_result") + ) + summary["artifact_sha256"] = ( + None if retained_result is None else _sha256(retained_result) + ) + summaries.append(summary) + continue + artifact_path = _verified_identity(root, raw_record.get("artifact")) + payload = cast(dict[str, Any], json.loads(artifact_path.read_text())) + if payload.get("schema_version") != 1: + raise ValueError("unsupported M14a worker schema") + payload_context = payload.get("execution_context") + if not isinstance(payload_context, dict): + raise ValueError("worker execution context is missing") + for name in ("git_commit", "source_fingerprint", *ENVIRONMENT_FIELDS): + if payload_context.get(name) != context.get(name): + raise ValueError(f"worker {name} differs from manifest") + provenance_clean = ( + provenance_clean and payload_context.get("worktree_clean") is True + ) + if ( + payload.get("case"), + payload.get("formulation"), + _required_int(payload.get("horizon"), "worker horizon"), + ) != (case_name, formulation, horizon): + raise ValueError("worker point identity differs from manifest") + if payload.get("temporal_assembly") != "stepwise": + raise ValueError("worker did not use legacy stepwise assembly") + expected_backend = "DNLP_IPOPT" if formulation == "ac" else "CPP" + if payload.get("canonicalization_backend") != expected_backend: + raise ValueError("worker canonicalization backend mismatch") + if phase_path is None: + raise ValueError("completed worker phase journal is missing") + _validate_phase_journal(phase_path, convex=formulation != "ac") + if payload.get("status") not in {cp.OPTIMAL, cp.OPTIMAL_INACCURATE}: + raise ValueError("completed worker does not contain an accepted solve") + residuals = payload.get("residuals") + if not isinstance(residuals, dict) or not residuals: + raise ValueError("worker residual mapping is missing") + residual_values = np.asarray(list(residuals.values()), dtype=float) + if not np.isfinite(residual_values).all() or np.any(residual_values < 0): + raise ValueError("worker residuals must be finite and nonnegative") + maximum_residual = float(np.max(residual_values)) + if maximum_residual > AUDIT_TOLERANCE: + raise ValueError("worker residual exceeds the M14a audit tolerance") + result = payload.get("result") + if not isinstance(result, dict): + raise ValueError("worker result mapping is missing") + retained_audit_inputs = payload.get("audit_inputs") + if not isinstance(retained_audit_inputs, dict): + raise ValueError("worker audit inputs are missing") + reconstructed_residuals = audit_result_from_inputs( + formulation, retained_audit_inputs, result + ) + if reconstructed_residuals.keys() != residuals.keys() or any( + not np.isclose( + reconstructed_residuals[name], + float(residuals[name]), + rtol=0.0, + atol=1e-12, + ) + for name in reconstructed_residuals + ): + raise ValueError("worker residual mapping does not reconstruct exactly") + schema = payload.get("result_schema") + if not _serialized_schema_matches(result, schema): + raise ValueError("worker result schema does not match retained result") + _validate_measurements(payload, formulation) + timing = cast(dict[str, Any], payload["timing_seconds"]) + memory = cast(dict[str, Any], payload["peak_rss_bytes"]) + serialized_result = ( + json.dumps(result, sort_keys=True, separators=(",", ":"), allow_nan=False) + + "\n" + ).encode() + if payload.get("serialized_result_bytes") != len(serialized_result): + raise ValueError("serialized result size mismatch") + summary.update( + { + "artifact_sha256": _sha256(artifact_path), + "artifact_bytes": artifact_path.stat().st_size, + "source_structure": payload.get("source_structure"), + "source_structure_sha256": _digest(payload.get("source_structure")), + "canonical_structure": payload.get("canonical_structure"), + "canonical_structure_sha256": _digest( + payload.get("canonical_structure") + ), + "result_schema_sha256": _digest(schema), + "result_sha256": _digest(result), + "scientific_scalars": { + name: value + for name, value in result.items() + if value is None + or (isinstance(value, (int, float)) and not isinstance(value, bool)) + }, + "audit_inputs_sha256": _digest(retained_audit_inputs), + "maximum_residual": maximum_residual, + "timing_seconds": timing, + "peak_rss_bytes": memory, + "serialized_result_bytes": payload.get("serialized_result_bytes"), + } + ) + summaries.append(summary) + + while expected_index < len(expected) and expected[expected_index][0] in stopped: + expected_index += 1 + if expected_index != len(expected): + complete = False + accepted_as_ladder_record = complete and provenance_clean + return { + "schema_version": 1, + "stage": "M14a_legacy_baseline", + "frozen_ladder": ladder, + "execution_complete": complete, + "accepted_as_ladder_record": accepted_as_ladder_record, + "audit_tolerance": AUDIT_TOLERANCE, + "execution_context": context, + "analysis_context": { + "git_commit": _git("rev-parse", "HEAD"), + "worktree_clean": _git("status", "--porcelain") == "", + "source_fingerprint": _analysis_source_fingerprint(), + }, + "manifest": { + "bytes": manifest_path.stat().st_size, + "sha256": _sha256(manifest_path), + }, + "points": summaries, + } + + +def analyze_runs(directories: list[Path]) -> dict[str, Any]: + """Combine the two frozen ladders into the M14a advancement record.""" + runs: dict[str, dict[str, Any]] = {} + for directory in directories: + run = analyze_run(directory) + ladder = str(run["frozen_ladder"]) + if ladder in runs: + raise ValueError("duplicate frozen M14a ladder") + runs[ladder] = run + if set(runs) != set(FROZEN_LADDERS): + raise ValueError("M14a advancement requires every frozen ladder") + contexts = [run["execution_context"] for run in runs.values()] + for name in ("git_commit", "source_fingerprint", *ENVIRONMENT_FIELDS): + if any(context.get(name) != contexts[0].get(name) for context in contexts[1:]): + raise ValueError(f"M14a ladder {name} values do not match") + analysis_context = { + "git_commit": _git("rev-parse", "HEAD"), + "worktree_clean": _git("status", "--porcelain") == "", + "source_fingerprint": _analysis_source_fingerprint(), + } + analysis_matches_execution = ( + analysis_context["worktree_clean"] is True + and analysis_context["git_commit"] == contexts[0].get("git_commit") + and analysis_context["source_fingerprint"] + == contexts[0].get("source_fingerprint") + ) + return { + "schema_version": 1, + "stage": "M14a_legacy_baseline", + "execution_complete": all(run["execution_complete"] for run in runs.values()), + "accepted_for_m14b": all( + run["accepted_as_ladder_record"] for run in runs.values() + ) + and analysis_matches_execution, + "execution_commit": contexts[0].get("git_commit"), + "execution_source_fingerprint": contexts[0].get("source_fingerprint"), + "analysis_context": analysis_context, + "ladders": runs, + } + + +def _promote(path: Path, payload: dict[str, Any]) -> None: + if not payload["execution_complete"]: + raise ValueError("an incomplete M14a run cannot be promoted") + if not payload["accepted_for_m14b"]: + raise ValueError("an M14a run without clean provenance cannot be promoted") + analysis_context = payload.get("analysis_context") + if not isinstance(analysis_context, dict) or ( + analysis_context.get("worktree_clean") is not True + or analysis_context.get("git_commit") != payload.get("execution_commit") + or analysis_context.get("source_fingerprint") + != payload.get("execution_source_fingerprint") + ): + raise ValueError("analysis provenance does not match the execution source") + data = ( + json.dumps(payload, sort_keys=True, indent=2, allow_nan=False) + "\n" + ).encode() + path.parent.mkdir(parents=True, exist_ok=True) + descriptor = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o644) + with os.fdopen(descriptor, "wb") as stream: + stream.write(data) + stream.flush() + os.fsync(stream.fileno()) + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("run_directories", type=Path, nargs="+") + parser.add_argument("--promote", type=Path) + arguments = parser.parse_args() + result = analyze_runs(arguments.run_directories) + if arguments.promote is not None: + _promote(arguments.promote, result) + print(json.dumps(result, sort_keys=True, indent=2, allow_nan=False)) + + +if __name__ == "__main__": + main() diff --git a/experiments/m14_time_vectorization/run_m14a.py b/experiments/m14_time_vectorization/run_m14a.py index 7daa104..94eb624 100644 --- a/experiments/m14_time_vectorization/run_m14a.py +++ b/experiments/m14_time_vectorization/run_m14a.py @@ -26,6 +26,7 @@ from cvxopf.results import extract_results from experiments.m14_time_vectorization.baseline import ( BaselineCase, + audit_inputs, audit_result, build_baseline_fixture, json_result, @@ -36,6 +37,22 @@ FORMULATIONS = ("ac", "lossy_dc", "singlenode_dc") ROOT = Path(__file__).resolve().parents[2] +# M14a characterizes the legacy graph only as far as it remains useful and +# operationally bounded. These schedules are scientific protocol, not +# adaptive defaults: a failed point stops only that formulation's later points. +FROZEN_LADDERS: dict[str, tuple[tuple[str, int, str], ...]] = { + "case9": ( + *(("ac", horizon, "case9") for horizon in (1, 2, 4, 8, 24)), + *(("lossy_dc", horizon, "case9") for horizon in (1, 2, 4, 8, 24, 168)), + *(("singlenode_dc", horizon, "case9") for horizon in (1, 2, 4, 8, 24, 168)), + ), + "case118": ( + *(("ac", horizon, "case118") for horizon in (1, 3)), + *(("lossy_dc", horizon, "case118") for horizon in (24, 168, 720)), + *(("singlenode_dc", horizon, "case118") for horizon in (24, 168, 720, 8760)), + ), +} + def _sha256(path: Path) -> str: digest = hashlib.sha256() @@ -76,6 +93,14 @@ def _package_version(name: str) -> str | None: return None +def _ipopt_version() -> str | None: + try: + from cyipopt import IPOPT_VERSION + except ImportError: + return None + return ".".join(str(value) for value in IPOPT_VERSION) + + def _execution_context() -> dict[str, Any]: status = _git("status", "--porcelain") return { @@ -88,7 +113,8 @@ def _execution_context() -> dict[str, Any]: "packages": { name: _package_version(name) for name in ("cvxpy", "clarabel", "cyipopt", "numpy", "scipy") - }, + } + | {"ipopt": _ipopt_version()}, } @@ -220,6 +246,7 @@ def measure_point( "source_structure": asdict(source), "canonical_structure": None if canonical is None else asdict(canonical), "result_schema": result_schema(result), + "audit_inputs": audit_inputs(fixture), "residuals": residuals, "result": result_payload, "serialized_result_bytes": len(result_bytes), @@ -293,110 +320,132 @@ def _run_parent(args: argparse.Namespace) -> None: parent_context = _execution_context() if not parent_context["git_commit"] or not parent_context["source_fingerprint"]: raise RuntimeError("parent execution provenance is unavailable") - if not args.horizons or any(horizon <= 0 for horizon in args.horizons): + frozen_ladder = getattr(args, "frozen_ladder", None) + if frozen_ladder is None and ( + not args.horizons or any(horizon <= 0 for horizon in args.horizons) + ): raise ValueError("horizons must contain positive integers") if args.timeout_seconds <= 0: raise ValueError("timeout_seconds must be positive") + if frozen_ladder is None: + points = tuple( + (formulation, horizon, args.case) + for formulation in args.formulations + for horizon in args.horizons + ) + else: + points = FROZEN_LADDERS[frozen_ladder] + required_formulations = {point[0] for point in points} + if set(args.formulations) != required_formulations: + raise ValueError( + "a frozen ladder requires its complete formulation registry" + ) output.mkdir(parents=True, exist_ok=False) records: list[dict[str, Any]] = [] - for formulation in args.formulations: - for horizon in args.horizons: - destination = output / f"{formulation}-{horizon:05d}.json" - command = [ - sys.executable, - "-m", - "experiments.m14_time_vectorization.run_m14a", - "--worker", - "--formulation", - formulation, - "--horizon", - str(horizon), - "--case", - args.case, - "--output", - str(destination), - "--expected-commit", - str(parent_context["git_commit"]), - "--expected-source-fingerprint", - str(parent_context["source_fingerprint"]), - ] - classification = "completed" - try: - completed = subprocess.run( - command, - cwd=ROOT, - check=False, - capture_output=True, - timeout=args.timeout_seconds, - ) - returncode = completed.returncode - stdout = completed.stdout - stderr = completed.stderr - if returncode != 0: - classification = "worker_failure" - except subprocess.TimeoutExpired as error: - returncode = None - classification = "wall_time_limit" - stdout = error.stdout or b"" - stderr = error.stderr or b"" - log_path = destination.with_suffix(".log") - _write_immutable_bytes( - log_path, - b"--- stdout ---\n" + stdout + b"\n--- stderr ---\n" + stderr, + stopped_formulations: set[str] = set() + for formulation, horizon, case_name in points: + if formulation in stopped_formulations: + continue + if frozen_ladder is None and formulation not in args.formulations: + continue + destination = output / f"{formulation}-{horizon:05d}.json" + command = [ + sys.executable, + "-m", + "experiments.m14_time_vectorization.run_m14a", + "--worker", + "--formulation", + formulation, + "--horizon", + str(horizon), + "--case", + case_name, + "--output", + str(destination), + "--expected-commit", + str(parent_context["git_commit"]), + "--expected-source-fingerprint", + str(parent_context["source_fingerprint"]), + ] + classification = "completed" + try: + completed = subprocess.run( + command, + cwd=ROOT, + check=False, + capture_output=True, + timeout=args.timeout_seconds, ) - artifact = None - if classification == "completed": - if not destination.exists(): - classification = "artifact_missing" + returncode = completed.returncode + stdout = completed.stdout + stderr = completed.stderr + if returncode != 0: + classification = "worker_failure" + except subprocess.TimeoutExpired as error: + returncode = None + classification = "wall_time_limit" + stdout = error.stdout or b"" + stderr = error.stderr or b"" + log_path = destination.with_suffix(".log") + _write_immutable_bytes( + log_path, + b"--- stdout ---\n" + stdout + b"\n--- stderr ---\n" + stderr, + ) + artifact = None + if classification == "completed": + if not destination.exists(): + classification = "artifact_missing" + else: + try: + payload = _validate_worker_artifact( + destination, + formulation=formulation, + horizon=horizon, + case_name=case_name, + parent_context=parent_context, + ) + phase_path = destination.with_suffix(".phases.jsonl") + _validate_phase_journal(phase_path, convex=formulation != "ac") + except ( + FileNotFoundError, + KeyError, + TypeError, + ValueError, + json.JSONDecodeError, + ): + classification = "artifact_invalid" else: - try: - payload = _validate_worker_artifact( - destination, - formulation=formulation, - horizon=horizon, - case_name=args.case, - parent_context=parent_context, - ) - phase_path = destination.with_suffix(".phases.jsonl") - _validate_phase_journal(phase_path, convex=formulation != "ac") - except ( - FileNotFoundError, - KeyError, - TypeError, - ValueError, - json.JSONDecodeError, - ): - classification = "artifact_invalid" - else: - artifact = _artifact_identity(destination) - if payload["status"] not in { - cp.OPTIMAL, - cp.OPTIMAL_INACCURATE, - }: - classification = "solve_not_accepted" - evidence = {"log": _artifact_identity(log_path)} - phase_path = destination.with_suffix(".phases.jsonl") - if phase_path.exists(): - evidence["phases"] = _artifact_identity(phase_path) - if destination.exists() and artifact is None: - evidence["unvalidated_result"] = _artifact_identity(destination) - records.append( - { - "formulation": formulation, - "horizon": horizon, - "classification": classification, - "returncode": returncode, - "artifact": artifact, - "evidence": evidence, - } - ) - if classification != "completed": - break + artifact = _artifact_identity(destination) + if payload["status"] not in { + cp.OPTIMAL, + cp.OPTIMAL_INACCURATE, + }: + classification = "solve_not_accepted" + evidence = {"log": _artifact_identity(log_path)} + phase_path = destination.with_suffix(".phases.jsonl") + if phase_path.exists(): + evidence["phases"] = _artifact_identity(phase_path) + if destination.exists() and artifact is None: + evidence["unvalidated_result"] = _artifact_identity(destination) + records.append( + { + "formulation": formulation, + "horizon": horizon, + "case": case_name, + "classification": classification, + "returncode": returncode, + "artifact": artifact, + "evidence": evidence, + } + ) + if classification != "completed": + stopped_formulations.add(formulation) _write_immutable( output / "manifest.json", { "schema_version": 1, "execution_context": parent_context, + "frozen_ladder": frozen_ladder, "timeout_seconds_per_point": args.timeout_seconds, "records": records, }, @@ -409,6 +458,7 @@ def _parser() -> argparse.ArgumentParser: parser.add_argument("--formulation", choices=FORMULATIONS) parser.add_argument("--horizon", type=int) parser.add_argument("--case", choices=("case9", "case118"), default="case9") + parser.add_argument("--frozen-ladder", choices=tuple(FROZEN_LADDERS)) parser.add_argument("--output", type=Path, required=True) parser.add_argument( "--formulations", nargs="+", choices=FORMULATIONS, default=FORMULATIONS diff --git a/tests/test_m14a_analysis.py b/tests/test_m14a_analysis.py new file mode 100644 index 0000000..222a9e2 --- /dev/null +++ b/tests/test_m14a_analysis.py @@ -0,0 +1,277 @@ +"""Independent M14a scaling-record reconstruction tests.""" + +import json +import hashlib +from pathlib import Path +from types import SimpleNamespace + +import pytest + +from experiments.m14_time_vectorization import run_m14a +from experiments.m14_time_vectorization.m14a_analysis import ( + _promote, + _validate_classification_record, + analyze_run, + analyze_runs, +) + + +def _small_frozen_ladder(monkeypatch: pytest.MonkeyPatch) -> None: + ladder = (("singlenode_dc", 1, "case9"),) + monkeypatch.setitem(run_m14a.FROZEN_LADDERS, "case9", ladder) + import experiments.m14_time_vectorization.m14a_analysis as analysis + + monkeypatch.setitem(analysis.FROZEN_LADDERS, "case9", ladder) + + +def test_frozen_ladders_are_formulation_specific_and_ordered(): + case9 = run_m14a.FROZEN_LADDERS["case9"] + case118 = run_m14a.FROZEN_LADDERS["case118"] + + assert [point[1] for point in case9 if point[0] == "ac"] == [1, 2, 4, 8, 24] + assert [point[1] for point in case118 if point[0] == "lossy_dc"] == [ + 24, + 168, + 720, + ] + assert [point[1] for point in case118 if point[0] == "singlenode_dc"][-1] == 8760 + + +def test_frozen_ladder_rejects_formulation_subset(tmp_path: Path): + with pytest.raises(ValueError, match="complete formulation registry"): + run_m14a._run_parent( + SimpleNamespace( + output=tmp_path / "run", + formulations=["lossy_dc"], + horizons=[1], + case="case9", + frozen_ladder="case9", + timeout_seconds=30.0, + ) + ) + + +def test_complete_frozen_run_is_independently_reconstructed( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +): + _small_frozen_ladder(monkeypatch) + output = tmp_path / "run" + run_m14a._run_parent( + SimpleNamespace( + output=output, + formulations=["singlenode_dc"], + horizons=[99], + case="case118", + frozen_ladder="case9", + timeout_seconds=30.0, + ) + ) + + result = analyze_run(output) + + assert result["execution_complete"] is True + assert ( + result["accepted_as_ladder_record"] + is result["execution_context"]["worktree_clean"] + ) + assert len(result["points"]) == 1 + assert result["points"][0]["horizon"] == 1 + assert result["points"][0]["classification"] == "completed" + assert result["points"][0]["maximum_residual"] <= result["audit_tolerance"] + + +def test_analysis_rejects_tampered_worker_artifact( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +): + _small_frozen_ladder(monkeypatch) + output = tmp_path / "run" + run_m14a._run_parent( + SimpleNamespace( + output=output, + formulations=["singlenode_dc"], + horizons=[1], + case="case9", + frozen_ladder="case9", + timeout_seconds=30.0, + ) + ) + artifact = output / "singlenode_dc-00001.json" + payload = json.loads(artifact.read_text()) + payload["residuals"]["storage_recurrence_mwh_abs"] = 1.0 + artifact.write_text(json.dumps(payload)) + + with pytest.raises(ValueError, match="size mismatch|hash mismatch"): + analyze_run(output) + + +def test_analysis_independently_reconstructs_residuals( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +): + _small_frozen_ladder(monkeypatch) + output = tmp_path / "run" + run_m14a._run_parent( + SimpleNamespace( + output=output, + formulations=["singlenode_dc"], + horizons=[1], + case="case9", + frozen_ladder="case9", + timeout_seconds=30.0, + ) + ) + artifact = output / "singlenode_dc-00001.json" + payload = json.loads(artifact.read_text()) + payload["residuals"]["storage_recurrence_mwh_abs"] = 1e-7 + artifact.write_text(json.dumps(payload)) + manifest_path = output / "manifest.json" + manifest = json.loads(manifest_path.read_text()) + identity = manifest["records"][0]["artifact"] + identity["bytes"] = artifact.stat().st_size + identity["sha256"] = hashlib.sha256(artifact.read_bytes()).hexdigest() + manifest_path.write_text(json.dumps(manifest)) + + with pytest.raises(ValueError, match="does not reconstruct exactly"): + analyze_run(output) + + +def test_incomplete_run_cannot_be_promoted(tmp_path: Path): + destination = tmp_path / "M14A_RESULTS.json" + with pytest.raises(ValueError, match="incomplete"): + _promote( + destination, + {"execution_complete": False, "accepted_for_m14b": False}, + ) + assert not destination.exists() + + +def test_complete_promotion_is_immutable(tmp_path: Path): + destination = tmp_path / "M14A_RESULTS.json" + payload = { + "execution_complete": True, + "accepted_for_m14b": True, + "execution_commit": "commit", + "execution_source_fingerprint": "source", + "analysis_context": { + "git_commit": "commit", + "source_fingerprint": "source", + "worktree_clean": True, + }, + "value": 1, + } + _promote(destination, payload) + changed = dict(payload, value=2) + with pytest.raises(FileExistsError): + _promote(destination, changed) + assert json.loads(destination.read_text()) == payload + + +def test_consolidation_requires_both_frozen_ladders( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +): + _small_frozen_ladder(monkeypatch) + output = tmp_path / "run" + run_m14a._run_parent( + SimpleNamespace( + output=output, + formulations=["singlenode_dc"], + horizons=[1], + case="case9", + frozen_ladder="case9", + timeout_seconds=30.0, + ) + ) + with pytest.raises(ValueError, match="every frozen ladder"): + analyze_runs([output]) + + +def _synthetic_run(ladder: str, *, platform: str = "platform") -> dict: + return { + "frozen_ladder": ladder, + "execution_complete": True, + "accepted_as_ladder_record": True, + "execution_context": { + "git_commit": "commit", + "source_fingerprint": "source", + "worktree_clean": True, + "platform": platform, + "machine": "machine", + "python": "3.11", + "packages": {"cvxpy": "1", "ipopt": "2"}, + }, + } + + +def test_complete_consolidation_requires_matched_environment( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +): + import experiments.m14_time_vectorization.m14a_analysis as analysis + + runs = { + "case9": _synthetic_run("case9"), + "case118": _synthetic_run("case118"), + } + monkeypatch.setattr(analysis, "analyze_run", lambda path: runs[path.name]) + monkeypatch.setattr( + analysis, + "_git", + lambda *args: "" if args == ("status", "--porcelain") else "commit", + ) + monkeypatch.setattr(analysis, "_analysis_source_fingerprint", lambda: "source") + + result = analyze_runs([tmp_path / "case9", tmp_path / "case118"]) + assert result["execution_complete"] is True + assert result["accepted_for_m14b"] is True + + runs["case118"] = _synthetic_run("case118", platform="other") + with pytest.raises(ValueError, match="platform"): + analyze_runs([tmp_path / "case9", tmp_path / "case118"]) + + +def test_dirty_analysis_cannot_advance_or_promote( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +): + import experiments.m14_time_vectorization.m14a_analysis as analysis + + runs = { + "case9": _synthetic_run("case9"), + "case118": _synthetic_run("case118"), + } + monkeypatch.setattr(analysis, "analyze_run", lambda path: runs[path.name]) + monkeypatch.setattr( + analysis, + "_git", + lambda *args: "dirty" if args == ("status", "--porcelain") else "commit", + ) + monkeypatch.setattr(analysis, "_analysis_source_fingerprint", lambda: "source") + result = analyze_runs([tmp_path / "case9", tmp_path / "case118"]) + assert result["accepted_for_m14b"] is False + with pytest.raises(ValueError, match="clean provenance"): + _promote(tmp_path / "result.json", result) + + +@pytest.mark.parametrize( + "record", + [ + { + "classification": "completed", + "returncode": 1, + "artifact": {"path": "result.json"}, + "evidence": {}, + }, + { + "classification": "wall_time_limit", + "returncode": 0, + "artifact": None, + "evidence": {}, + }, + { + "classification": "solve_not_accepted", + "returncode": 0, + "artifact": None, + "evidence": {}, + }, + ], +) +def test_classification_matrix_rejects_contradictory_records(record): + with pytest.raises(ValueError, match="classification evidence"): + _validate_classification_record(record) From 7195e325be5e6327155f1e69982774c6a2e0c922 Mon Sep 17 00:00:00 2001 From: Bennet Meyers Date: Tue, 25 Aug 2026 22:13:16 -0700 Subject: [PATCH 08/28] fix: preserve parameter identities in M14a schemas Record parameter names, shapes, and duplicate multiplicity in source-graph characterization, and strengthen the frozen core and full-component regressions against parameter-schema drift. --- src/cvxopf/characterization.py | 18 ++++++++++++++---- tests/test_m14_characterization.py | 8 +++++--- tests/test_m14a_baseline.py | 23 ++++++++++++++++++++--- 3 files changed, 39 insertions(+), 10 deletions(-) diff --git a/src/cvxopf/characterization.py b/src/cvxopf/characterization.py index 2a8cc70..bfbf96c 100644 --- a/src/cvxopf/characterization.py +++ b/src/cvxopf/characterization.py @@ -36,6 +36,7 @@ class SourceGraphStructure: variable_schema: tuple[NamedShape, ...] expression_schema: tuple[NamedShape, ...] data_keys: tuple[str, ...] + parameter_schema: tuple[NamedShape, ...] parameter_shapes: tuple[tuple[int, ...], ...] variable_object_count: int parameter_object_count: int @@ -85,6 +86,15 @@ def _mapping_schema(mapping: Mapping[str, object]) -> tuple[NamedShape, ...]: return tuple(records) +def _parameter_schema(parameters: list[cp.Parameter]) -> tuple[NamedShape, ...]: + grouped: dict[str, list[tuple[int, ...]]] = {} + for parameter in parameters: + grouped.setdefault(str(parameter.name()), []).append(_shape(parameter)) + return tuple( + NamedShape(name, tuple(sorted(grouped[name]))) for name in sorted(grouped) + ) + + def characterize_source_graph(build: OPFBuild) -> SourceGraphStructure: """Capture stable schemas and representation-specific source counts.""" constraints = build.prob.constraints @@ -95,6 +105,7 @@ def characterize_source_graph(build: OPFBuild) -> SourceGraphStructure: isinstance(constraint, cp.constraints.Inequality) for constraint in constraints ) metrics = build.prob.size_metrics + parameters = build.prob.parameters() horizon_value = build.data.get("T") horizon = None if horizon_value is None else int(horizon_value) return SourceGraphStructure( @@ -104,11 +115,10 @@ def characterize_source_graph(build: OPFBuild) -> SourceGraphStructure: variable_schema=_mapping_schema(build.variables), expression_schema=_mapping_schema(build.expressions), data_keys=tuple(sorted(str(key) for key in build.data)), - parameter_shapes=tuple( - sorted(_shape(parameter) for parameter in build.prob.parameters()) - ), + parameter_schema=_parameter_schema(parameters), + parameter_shapes=tuple(sorted(_shape(parameter) for parameter in parameters)), variable_object_count=len(build.prob.variables()), - parameter_object_count=len(build.prob.parameters()), + parameter_object_count=len(parameters), constraint_object_count=len(constraints), equality_object_count=equality_count, inequality_object_count=inequality_count, diff --git a/tests/test_m14_characterization.py b/tests/test_m14_characterization.py index 02c0d60..d80fa2f 100644 --- a/tests/test_m14_characterization.py +++ b/tests/test_m14_characterization.py @@ -12,6 +12,7 @@ from cvxopf import build_opf, build_opf_multistep from cvxopf.characterization import ( + NamedShape, characterize_convex_canonicalization, characterize_source_graph, ) @@ -19,10 +20,10 @@ SOURCE_GRAPH_DIGESTS = { - "ac": "7f69a7694e27983d48fc071ee1cfd84b58fba371aa22bda27b6ebe9347767633", - "lossy_dc": "90f376331ca7912f068e96875a6296ddb868b7debab64e8d566d542627eaecd4", + "ac": "60df7473cf05f07b852406b6c98dea51af5491efd5d9970d2265b569f9862e07", + "lossy_dc": "0f35650806830f468c1719afec5f3051331bb7a44820cc70b2a9e8b8044ee497", "singlenode_dc": ( - "e19b20b4ea86588fdf45210b3df3217691faf27cfd055d7ccc1673fcab09ad5f" + "7db1ad0a263a5b049221db2ffcccf1201d49e3677fcc2f86fee0d951e1894f27" ), } @@ -75,6 +76,7 @@ def test_stepwise_source_graph_baseline(formulation, expected): assert "temporal_assembly" not in build.data assert record.temporal_assembly == "stepwise" assert record.horizon == 2 + assert record.parameter_schema == (NamedShape("load_inv_base_mva", ((), ())),) assert ( record.scalar_variables, record.scalar_equalities, diff --git a/tests/test_m14a_baseline.py b/tests/test_m14a_baseline.py index 81c86b0..0b24613 100644 --- a/tests/test_m14a_baseline.py +++ b/tests/test_m14a_baseline.py @@ -64,10 +64,10 @@ } FULL_SOURCE_DIGESTS = { - "ac": "edeb22b142edc2342543e0c88aa2d7bf1040cc4549089bebb743fec3cd2ad42d", - "lossy_dc": ("de40a7a65ab125bbdd699f0daeccc6b2afcc88b9f08fdc9cda04b35d154cb661"), + "ac": "57854005fb90eebd02c5bb740c3d66d1e1f718bd8a98a755121696cbb54529c7", + "lossy_dc": ("f1eaeb6880471a7cee874d3eba50524d00c1895c5a309686237701847560d87e"), "singlenode_dc": ( - "1da6f9ecc3880440b8d4f81b950d22b74807e5c6de9ff4275cd9eda67b2fdf1f" + "bcdc9b99da36a6e165875ddf11ba91bd3ab0a304ffb3e4edaaabcf0db842e846" ), } @@ -138,6 +138,23 @@ def test_full_component_fixture_retains_schema_and_physical_audit(formulation): json.dumps(asdict(source), sort_keys=True, separators=(",", ":")).encode() ).hexdigest() assert source_digest == FULL_SOURCE_DIGESTS[formulation] + parameter_schema = { + record.name: record.shapes for record in source.parameter_schema + } + assert parameter_schema["load_inv_base_mva"] == ((), ()) + assert parameter_schema["load_p_mw"] == ((2, 3),) + assert parameter_schema["load_p_eligible_mw"] == ((2, 3),) + assert parameter_schema["load_eligibility_mask"] == ((2, 3),) + assert parameter_schema["storage_inv_baseMVA"] == ((), ()) + assert parameter_schema["nd_inv_baseMVA"] == ((), ()) + if formulation == "ac": + assert parameter_schema["load_q_mvar"] == ((2, 3),) + else: + assert "load_q_mvar" not in parameter_schema + if formulation != "singlenode_dc": + assert parameter_schema["hvdc_inv_baseMVA"] == ((), ()) + else: + assert "hvdc_inv_baseMVA" not in parameter_schema if formulation != "ac": canonical = characterize_convex_canonicalization(fixture.build) assert ( From 1dd5e36dcae5ad9c8176b1d1202f1055acf95c03 Mon Sep 17 00:00:00 2001 From: Bennet Meyers Date: Tue, 25 Aug 2026 22:14:04 -0700 Subject: [PATCH 09/28] docs: explain lifted branch constraints --- .../cvxopf_project_update.tex | 33 +++++++++++++++---- 1 file changed, 26 insertions(+), 7 deletions(-) diff --git a/presentations/weekly_update_20260826/cvxopf_project_update.tex b/presentations/weekly_update_20260826/cvxopf_project_update.tex index cad1633..30de0d5 100644 --- a/presentations/weekly_update_20260826/cvxopf_project_update.tex +++ b/presentations/weekly_update_20260826/cvxopf_project_update.tex @@ -142,14 +142,33 @@ \end{columns} \end{frame} -\begin{frame}[shrink=3]{Equivalent mathematics can have radically different numerical behavior} +\begin{frame}[shrink=3]{The same branch limit can have very different numerical behavior} + \begin{columns}[T,onlytextwidth] + \column{0.47\textwidth} + \centering + \textbf{Direct constraint} + \[ + P_e(V)^2 + Q_e(V)^2 \leq \overline S_e^2 + \] + \scriptsize Put the nonlinear voltage-based terminal-flow expressions + directly inside the thermal inequality. + + \column{0.47\textwidth} + \centering + \textbf{Lifted constraint} + \[ + \widehat P_e=P_e(V),\quad \widehat Q_e=Q_e(V), + \qquad + \widehat P_e^2 + \widehat Q_e^2 \leq \overline S_e^2 + \] + \scriptsize Name the same terminal powers with auxiliary variables, then + constrain those variables. Here $e\in\{\mathrm{from},\mathrm{to}\}$. + \end{columns} + \vspace{0.2em} \centering - \includegraphics[width=0.98\textwidth,height=0.68\textheight,keepaspectratio]{formulation_results.pdf} - \begin{itemize}\small\tightitems - \item Direct and lifted branch-terminal equations agree below $4.5\times10^{-14}$ p.u.; paired objectives agree to solver precision. - \item Lifting adds variables and equalities but separates nonlinear voltage expressions from quadratic thermal inequalities. - \item On case57, the lifted structure was 27$\times$ faster in sparse form and 110$\times$ faster in dense form. - \end{itemize} + \includegraphics[width=0.98\textwidth,height=0.55\textheight,keepaspectratio]{formulation_results.pdf} + \small The terminal flows agree below $4.5\times10^{-14}$ p.u.; on case57, + lifting reduced solve time by 27$\times$ (sparse) and 110$\times$ (dense). \end{frame} \begin{frame}{Terminal energy is an economic decision, not a boundary detail} From 1782746309c53c937027a172e9df07f73785b82a Mon Sep 17 00:00:00 2001 From: Bennet Meyers Date: Wed, 26 Aug 2026 15:33:20 -0700 Subject: [PATCH 10/28] docs: clarify project thesis and resilience research direction - frame CVXOPF as a multi-fidelity resilience modeling framework - distinguish implemented capabilities from future uncertainty studies - document the PyPSA/CVXOPF modeling comparison - add rare-event uncertainty and nonconvex load-group research plans - refresh developer guidance for the M16+/M17 architecture --- CLAUDE.md | 108 +-- README.md | 120 ++-- .../PYPSA_CVXOPF_COMPARISON.md | 635 ++++++++++++++++++ ...stone-22-nonconvex-load-group-penalties.md | 418 ++++++++++++ .../rare-event-uncertainty-and-resilience.md | 594 ++++++++++++++++ 5 files changed, 1785 insertions(+), 90 deletions(-) create mode 100644 experiments/ecosystem_positioning/PYPSA_CVXOPF_COMPARISON.md create mode 100644 plans/milestone-22-nonconvex-load-group-penalties.md create mode 100644 plans/rare-event-uncertainty-and-resilience.md diff --git a/CLAUDE.md b/CLAUDE.md index 93700c1..db8ecfd 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -13,9 +13,12 @@ supporting multiple formulations: - **AC-OPF** via CVXPY's disciplined nonlinear programming (DNLP) framework, solved via IPOPT (nonconvex) - **Lossy DC OPF** as a convex QP, solved via CLARABEL +- **Single-node DC dispatch** as a convex copper-plate QP, solved via CLARABEL -It is designed for power systems research, with a focus on extensibility to -multi-step optimization and energy storage models. +It is designed for long-horizon power-system resilience research. The package +combines reusable device models, multistep optimization, and hierarchical +convex-to-AC execution so broad planning studies retain a deliberate path back +to nonlinear network physics. The package is developed by the CVX Group at Stanford. @@ -64,7 +67,13 @@ https://www.incontrolpodcast.com/1632769/episodes/12444508-ep10-stephen-boyd-lin ## Repository layout -`src/cvxopf/`: `problem.py` (public API), `ac_problem.py` / `dc_problem.py` / `singlenode_dc_problem.py` (per-formulation builders), `network.py`, `cost.py`, `data.py`, `results.py`, and one module per grid component (`storage.py`, `nondispatchable.py`, `hvdc.py`, `generator.py`). `testcases/` holds MATPOWER cases (case9–case118, PWL and dcline variants). `tests/`, `examples/`, `notebooks/`, and `scripts/` are top-level. Run `find src tests examples -name '*.py'` for the current file list. +`src/cvxopf/` contains the public build and hierarchical APIs, formulation +builders, shared typed component assembly, result extraction, and one module +per grid component (`generator.py`, `storage.py`, `nondispatchable.py`, +`hvdc.py`, and `load.py`). `testcases/` holds MATPOWER cases (case9–case118, +including PWL and dcline variants). `tests/`, `examples/`, `experiments/`, +`notebooks/`, `plans/`, and `scripts/` are top-level. Use `rg --files` for the +current inventory; do not treat this summary as an exhaustive file list. --- @@ -76,7 +85,8 @@ Always use `uv run` so the correct virtual environment and extras are used: uv run --extra dev pytest tests/ -v ``` -Expected result: all tests pass (baseline currently 865; run to confirm) +Expected result: all tests pass; use the collected count from the current +branch rather than a fixed historical test count. To run a single test file: @@ -117,6 +127,7 @@ Install with: `uv sync --extra dev --extra notebook` |---|---|---|---| | `False` | `"ac"` | `cp.IPOPT` | `True` | | `True` | `"lossy_dc"` | `cp.CLARABEL` | `False` | +| `True` | `"singlenode_dc"` | `cp.CLARABEL` | `False` | ```python build = build_opf(case9(), formulation="ac") @@ -284,7 +295,6 @@ without API changes. Planned future formulations: | Key | Description | |---|---| -| `"fast_decoupled"` | Fast-decoupled AC (convex) | | `"socp"` | SOCP relaxation (convex) | To add a new formulation, follow the complete formulation-extension contract @@ -348,7 +358,7 @@ of all stage-cost rates by `delta`. Terminal costs are not time-scaled. | `prob` | `cp.Problem` | The CVXPY problem | | `variables` | dict | Named CVXPY variables. AC keys depend on `sparse_pq` (`P_vec`/`Q_vec` or `P`/`Q`). When `storage` is not None, adds `b`, `b_q` (AC only), `soc` as `cp.Variable (ns,)` single-step or `list[cp.Variable]` multistep. When `nondispatchable` is not None, adds `p_nd`, `q_nd` (AC only) as `cp.Variable (nnd,)` single-step or `list[cp.Variable]` multistep. All storage keys absent when `storage=None`; all ND keys absent when `nondispatchable=None`. | | `data` | dict | Pre-computed numpy arrays and metadata. When storage is present, adds `ns`, `Cs`, `storage_bus`, `storage_apparent_power_rating`, `storage_capacity`, `storage_initial_soc`, `storage_device_ids`, `storage_device_id_is_explicit`, `storage_aging_weight`, `storage_delta`. When nondispatchable is present, adds `nnd`, `Cnd`, `nd_bus`, `nd_apparent_power_rating`, and either `nd_p_available` (single-step) or `nd_available` (multistep). `storage_bus` and `nd_bus` always use formulation-internal indexing; singlenode therefore uses collapsed bus `0`. Detection: `"ns" in build.data` for storage; `"nnd" in build.data` for nondispatchable. Empty component lists are normally absent; explicit `loads=[]` is the deliberate exception and publishes a complete zero-load schema. | -| `formulation` | str | `"ac"` or `"lossy_dc"` | +| `formulation` | str | `"ac"`, `"lossy_dc"`, or `"singlenode_dc"` | | `is_convex` | bool | Drives solver defaults in `solve()` | ### `StorageUnitIdeal` fields @@ -402,32 +412,38 @@ not use reactive power in optimization. ## Module responsibilities -`problem.py` is the **only** public-facing module. It imports from -`ac_problem.py` and `dc_problem.py` inside functions (not at module level) -to avoid circular imports. The import chain is: +`problem.py` owns the public OPF build boundary, while `hierarchical.py` owns +the public hierarchical-control boundary. Package-level exports in +`cvxopf.__init__` provide convenience imports. Formulation modules must remain +independent of one another. The principal dependency direction is: ``` problem.py → storage.py (StorageUnitIdeal, re-exported) problem.py → nondispatchable.py (NondispatchableUnit, re-exported) problem.py → generator.py (DispatchableGenerator, case normalization) +problem.py → load.py (Load, MATPOWER conversion, time-series preparation) problem.py → ac_problem.py (deferred, inside functions) problem.py → dc_problem.py (deferred, inside functions) +problem.py → singlenode_dc_problem.py (deferred, inside functions) formulation builders → _component_adapters.py (central component registry) _component_adapters.py → component modules (typed bindings to owned models) formulation builders → _component_assembly.py (generic contribution assembly) ac_problem.py → network.py, data.py dc_problem.py → network.py, data.py generator.py → cost.py (authoritative polynomial/PWL expressions) -results.py → problem.py (OPFBuild type only, unchanged) +hierarchical.py → problem.py (reviewed outer/inner build API) +results.py → problem.py (OPFBuild type boundary) storage.py → cvxpy, numpy (no other cvxopf imports) nondispatchable.py → data.py, cvxpy, numpy hvdc.py → data.py, cvxpy, numpy +load.py → cvxpy, numpy ``` `ac_problem.py` must not import from `dc_problem.py` and vice versa. -All four device modules now follow the M16 component pattern. See -`plans/milestone-16-unify-components.md`. +All five public device families—dispatchable generation, storage, +nondispatchable generation, HVDC, and loads—follow the typed M16+ component +pattern. See `plans/milestone-16-plus-component-adapters.md`. See [`PROJECT_FLOWCHART.md`](PROJECT_FLOWCHART.md) for the as-built problem-construction architecture, component lifecycle, ownership boundaries, @@ -515,8 +531,8 @@ is the sole place DNLP rules apply. Every device contribution — operating constraints, horizon-level temporal constraints, injection terms, and cost expressions for generators, storage, -nondispatchable units, and HVDC — must pass the ordinary DCP rules on its own. -No device model may rely on DNLP. Temporal constraints include state +nondispatchable units, HVDC, and loads — must pass the ordinary DCP rules on +their own. No device model may rely on DNLP. Temporal constraints include state transitions and temporal boundary conditions; keep those categories distinct inside the device implementation. @@ -531,14 +547,14 @@ Why this invariant matters: `ac_problem.py` Section 2. Anyone writing or reviewing a device model only needs the DCP rules below. (Do not change Section 2's DNLP flow definitions without understanding the paper — already a hard rule in "What not to do".) -- **SOCP (Milestone 11) integrates for free.** SOCP is a convex relaxation +- **SOCP (Milestone 11) reuses the device layer.** SOCP is a convex relaxation whose *network* physics are themselves DCP (second-order cone constraints on lifted variables — no DNLP bypass anywhere), making it the first fully-DCP network formulation. Because every device is already DCP, the SOCP - constructor composes the existing device methods unchanged; the only new work - is the cone network model plus a `socp_operating_constraints` fork for the - (few, if any) components whose feasible region differs in the lifted space. - Getting the M16 component contract right pre-pays SOCP's integration cost. + constructor can compose the existing DCP device contributions. The new work + remains substantial—network variables, cone constraints, audits, results, + and explicit component capability declarations—but does not require a second + implementation of every device model. When you add or edit a device model, assert `is_dcp()` on its constraints and cost **directly** (per-object checks below) — a device term that only passes @@ -605,8 +621,9 @@ Variable units are **not** uniform across all CVXPY variable types: `p`, `q`) are in **per-unit** internally (divided by `baseMVA`) and scaled to engineering units (MW, MVAr) in `extract_results`. - **Storage variables** (`b`, `b_q`, `soc`), **nondispatchable variables** - (`p_nd`, `q_nd`), and **HVDC variables** (`p_hvdc_in`, `p_hvdc_out`) are in - **engineering units** internally (MW, MVAr, MWh). + (`p_nd`, `q_nd`), **HVDC variables** (`p_hvdc_in`, `p_hvdc_out`), and load + power parameters and expressions are in **engineering units** internally + (MW, MVAr, MWh). The load interruption-fraction variable is dimensionless. They are **not** divided by `baseMVA` at declaration and are **not** multiplied by `baseMVA` in `extract_results`. They enter the nodal balance divided by `baseMVA` at the point of constraint construction — that division @@ -627,11 +644,12 @@ Variable units are **not** uniform across all CVXPY variable types: This matters for the DC formulation; AC bypasses DCP via DNLP/IPOPT. ### Multi-step structure -`build_opf_multistep` builds a **single `cp.Problem`** containing T sets +`build_opf_multistep` builds a **single `cp.Problem`** containing `T` sets of per-step variables and constraints. The objective integrates per-step cost rates using the global interval duration `delta`, then adds horizon-boundary -costs once. Coupling constraints (e.g., battery SoC dynamics) are passed via -`coupling_constraints` and appended without modification. +costs once. Component-owned horizon hooks contribute temporal dynamics and +terminal policies. The optional `coupling_constraints` argument carries +additional caller-supplied constraints and is appended without modification. ### Incidence matrices There are two distinct incidence matrices in `network.py`: @@ -667,18 +685,11 @@ multiplication path, causing `CvxpyDeprecationWarning`. This expression is a stage-cost rate; shared assembly multiplies its horizon sum by `delta`, so `aging_weight` has objective units/MWh of throughput. -`_make_step_constraints` (AC) is organised into five labelled sections in -fixed order, with Section 4b added for nondispatchable constraints: - 1. Reference bus angle fix - 2. Power flow definitions - 3. Nodal power balance (exactly one `p ==` and one `q ==` constraint; - all injection terms — storage and nondispatchable — combined here) - 4. Storage operating constraints - 4b. Nondispatchable operating constraints - 5. Voltage setpoint pinning - -This function owns all balance constraints (Section 3 emits exactly one -`p ==` and one `q ==`). +The AC network builder owns reference-angle constraints, nonlinear branch-flow +definitions, nodal balance, voltage limits, and branch operating limits. +Device operating sets and injections reach those balances through shared +component assembly; do not reconstruct device constraints inside the network +builder. Storage keys are absent from `build.data` when `storage=None`; the detection contract is `"ns" in build.data`. @@ -719,13 +730,13 @@ is present. | 4 — AC branch terminal flows and limits | ✅ Complete | Exact signed terminal-flow reporting in MATPOWER row order; positive finite `rateA` enforced as an apparent-power limit at both terminals by default. See `plans/milestone-4-branch-limits.md`. | | 5 — Battery/storage model hook | ✅ Complete | `StorageUnitIdeal`; `storage=` and `delta=` on `build_opf` / `build_opf_multistep`. AC apparent-power circle, DC real-power box; SoC cross-step coupling; L1 aging cost. See `plans/milestone-5-storage.md`. | | 6 — Lossy DC OPF and multi-formulation architecture | ✅ Complete | | -| 7 — HVDC transmission links | ✅ Complete | `HVDCLink`; `hvdc=` on `build_opf` / `build_opf_multistep`, `df_hvdc_min=`/`df_hvdc_max=` on multistep; `hvdc_from_dcline` MATPOWER importer. Signed nodal injections (Convention B), proportional loss on fixed-direction links; applies to `ac` and `lossy_dc`, silently dropped by `singlenode_dc`. Gate 6b is consistency-based, not a Pypower value-match. `LOSS0`/reactive/voltage-control deferred to M15. See `plans/milestone-7-hvdc.md` (incl. the `dcline` column map and MVP-vs-M15 subtable) and `experiments/dnlp_vs_pypower/`. | +| 7 — HVDC transmission links | ✅ Complete | `HVDCLink`; `hvdc=` on `build_opf` / `build_opf_multistep`, `df_hvdc_min=`/`df_hvdc_max=` on multistep; `hvdc_from_dcline` MATPOWER importer. Signed nodal injections (Convention B), proportional loss on fixed-direction links; applies to `ac` and `lossy_dc`, with an explicit null capability in `singlenode_dc` because network collapse eliminates both terminals. Gate 6b is consistency-based, not a Pypower value-match. `LOSS0`/reactive/voltage-control deferred to M15. See `plans/milestone-7-hvdc.md` (incl. the `dcline` column map and MVP-vs-M15 subtable) and `experiments/dnlp_vs_pypower/`. | | 8 — Nondispatchable generators | ✅ Complete | `NondispatchableUnit`; `nondispatchable=` and `df_nd=` on `build_opf` / `build_opf_multistep`. AC circle ∩ `0≤p_nd≤R_t`; DC retains separate availability and apparent-power-rating bounds; no cost/curtailment penalty. See `plans/milestone-8-nondispatchable.md`. | | 9 — Sparse P/Q variables for AC-OPF | ✅ Complete | `OPFOptions.sparse_pq` (default `True`); flat `P_vec`/`Q_vec` over Ybus pattern with scatter matrix `Rp`. See `plans/milestone-9-sparse-pq.md`. | | 10 — Single-node DC dispatch | ✅ Complete | `"singlenode_dc"` formulation; `make_singlenode_case` convenience constructor | | 11 — SOCP (convex) network model | 🔲 Future | | | 12 — Extend battery parameters: final SoC, penalty vs constraint | ✅ Complete | Storage-owned terminal equality or zero-shortfall constraints and linear/quadratic, one-/two-sided terminal costs, consistently composed across formulations. See `plans/milestone-12-storage-terminal-soc.md`. | -| 13 — Implement cvxpy parameters for problem data | 🔲 Future | Faster resolves of same problem over new data | +| 13 — Extend CVXPY parameterization for problem data | 🔲 Future | Faster repeated solves of the same graph over new data | | 14 — Time-vectorized multistep formulations | 🟧 Next / blocking | Add an explicit time-last tensor assembly mode using SCIPY canonicalization alongside the retained stepwise/CPP path, preserving formulation, failure, audit, and result contracts while enabling direct profiling of both temporal representations. Vectorized lossy DC is the first delivery and blocks resumption of the Case118 annual S4 outer solve after macOS killed the repeated annual graph under extreme compressed-memory pressure. See `plans/milestone-14-time-vectorization.md`. | | 15 — Full lossy HVDC (sign-switching converter losses) | 🔲 Future | charge/discharge-style split of `p_in`; adds fixed converter loss (`LOSS0`); enables losses in `free` and zero-straddling `band` steps; reactive-power support proposed. See `plans/milestone-15-full-lossy-hvdc.md`. | | 16 — Unify grid component model patterns | ✅ Complete | Generators, storage, nondispatchable units, and HVDC share formulation-specific injection and operating-set APIs, temporal coupling slots, and device-owned cost boundaries. Includes first-class `DispatchableGenerator`, MATPOWER fallback, stable identity for external ND/HVDC tables, and collapsed singlenode reuse. See `plans/milestone-16-unify-components.md` and `memories/M16-in-flight-record.md`. | @@ -734,6 +745,7 @@ is present. | 19 — First-class loads and explicit load shedding | ✅ Complete | Fixed active/reactive withdrawals use the shared device architecture, with MATPOWER conversion and identity-aligned explicit time series; configured loads add an affine served-fraction feasible set, proportional reactive relief, a sufficiently large linear value-of-lost-load cost, and conditional served/shed/ENS results in the same single solve. Controlled phase-transition, adequacy, AC/DC congestion, and multistep storage/renewable/terminal behavior are scientifically verified. No lexicographic or feasibility-restoration solve. See `plans/milestone-19-load-shedding.md`. | | 20 — AC voltage and reactive-dispatch regularization | 🔲 Future | Characterize whether reactive/voltage bound activity reflects physical support, unpriced nonuniqueness, or local-solver selection. Then add optional, normalized, time-integrated AC operating preferences with exact disabled-policy compatibility and measured economic displacement. No voltage-stability, market-pricing, or global-uniqueness claim. See `plans/milestone-20-ac-voltage-reactive-regularization.md`. | | 21 — Configurable and extensible formulation hierarchies | 🔲 Future | Generalize the completed M17 controller behind typed layer adapters and explicit, identity-aligned handoffs while preserving exact `lossy_dc`→`ac` compatibility. Support selectable planning formulations and validate a reference `singlenode_dc`→`socp`→`ac` hierarchy after M11 freezes SOCP relaxation and audit semantics. This remains a closed set of reviewed repository formulations, not an unrestricted plugin framework. See `plans/milestone-21-configurable-hierarchy.md`. | +| 22 — Nonconvex load-group penalties | 🔲 Future | Add identity-aligned interactions among groups of sheddable loads, beginning with mutually exclusive customer-group shedding and soft bilinear joint-shedding penalties. Use convex-hull or McCormick relaxation, typed deterministic rounding, and fixed-policy physical polishing; validate with exact small references, congested lossy-DC cases, and AC realization. See `plans/milestone-22-nonconvex-load-group-penalties.md`. | --- @@ -768,11 +780,12 @@ uv run scripts/generate_pypower_fixtures.py ``` This runs in an isolated sandbox with `pypower==5.1.19` and `numpy==2.2.6`. -The numpy pin is required because pypower uses `numpy.in1d` which was -removed in numpy 2.0. Do not run this script with the main package +The NumPy pin is required because PYPOWER uses `numpy.in1d`, which was removed +in NumPy 2.3. Do not run this script with the main package environment. Regenerate fixtures only if: + - A new test case is added to the package - A suspected bug in an existing fixture needs to be ruled out @@ -791,9 +804,12 @@ docstring. ## Fresh coding sessions -1. Read `CLAUDE.md` (this document) before touching code -2. Run `uv run --extra dev pytest tests/` first to confirm baseline -3. Check `git log --oneline -10` to orient on recent work +1. Read `CLAUDE.md` before touching code. +2. Inspect `git status --short` and preserve unrelated user changes. +3. Check `git log --oneline -10` and the relevant milestone or experiment + plan to orient on recent work. +4. Run proportionate baseline verification before editing; use the full suite + when the change or active stage requires it. --- @@ -832,9 +848,9 @@ docstring. - Do not select a lossy loss branch for a zero-straddling box (`p_min_t < 0 < p_max_t`) — the lossy branch is valid only for a fixed-direction box (`p_min_t >= 0` or `p_max_t <= 0`) -- Do not forward `hvdc`/`df_hvdc_min`/`df_hvdc_max` to `singlenode_dc` as a - live component — the singlenode builders accept and silently drop them - (no `"n_hvdc"` key, no `UserWarning`) +- Do not treat HVDC as a live component in `singlenode_dc`. Its registered + capability is explicitly `NULL` because collapsing both terminals removes + the link from the physical model (no `"n_hvdc"` key and no warning). - Do not skip the singlenode structural exceptions: `_parse_singlenode_dc_case` does not call `validate_case` (empty branch table by design), and `Pd_series` is shape `(T,)`, not `(T, nb)` — the formulation has no per-bus diff --git a/README.md b/README.md index 3abc635..887c0df 100644 --- a/README.md +++ b/README.md @@ -8,25 +8,44 @@ lossy DC OPF (convex QP), and single-node DC dispatch (convex QP). ## Motivation -Grid resiliency events rarely happen in an instant. The most dangerous -scenarios unfold over days: solar suppressed by sustained weather systems, -load elevated beyond seasonal norms, and battery storage depleted by -controllers that optimize for the current hour. Studying the -behavior of the modern grid under these conditions and developing optimal -control policies requires an optimization framework that is simultaneously -time-aware and physically grounded, that is able to plan dispatch strategy -across a full multi-day horizon and able to enforce the AC network -constraints that determine whether a plan is actually executable. - -`cvxopf` is designed with this application in mind. It formulates optimal power -flow problems using CVXPY, supports nonlinear AC-OPF, a convex lossy DC relaxation, -and single-node economic dispatch from a single entry point (with more to -come), and handles multi-step -optimization with time-varying load, battery storage, and nondispatchable generation -(wind, solar, hydro) natively. The intended use case is resiliency research: -studying how battery controllers should behave under adverse multi-day -conditions, how much temporal foresight matters, and how well convex -approximations track AC feasibility across extended horizons. +Grid resilience events rarely happen in an instant. The most consequential +scenarios can unfold over days, months, or longer: weather suppresses renewable +generation, demand remains elevated, geographically concentrated resources are +damaged, recovery is gradual, and short-sighted controllers deplete storage +before the system reaches its most constrained period. Studying these events +requires an optimization framework that is both time-aware and physically +grounded: it must coordinate decisions across long horizons while retaining +the AC network constraints that determine whether a plan is realizable. + +`cvxopf` is designed for that research problem. From one modeling framework it +supports nonlinear AC-OPF, convex lossy DC OPF, and single-node economic +dispatch, together with multistep load, generation, storage, and transmission +models. It is not intended merely as another OPF wrapper. It is the foundation +for a scientifically coherent method for studying long-duration, uncertain, +and compound resilience events without giving up access to nonlinear network +physics. + +Long horizons preserve modeled storage, resource, damage, and recovery states +across sequential events. Convex formulations make planning and broad scenario +screening tractable. Selected nonlinear AC-OPF intervals can then redispatch +active power, reactive support, and voltage state within the AC feasible set, +rather than merely checking a fixed coarse-model dispatch. + +The larger research program is organized around the chain + +```text +rare-event uncertainty + -> long-horizon adaptive planning + -> convex ensemble screening + -> nonlinear AC realization + -> audited resilience conclusions +``` + +The implemented package already provides the multi-fidelity component models, +intertemporal storage, hierarchical DC-to-AC state handoff, nonlinear-solver +recovery, and independent residual audits that support this direction. +General stochastic investment planning and GPU-batched uncertainty ensembles +remain research extensions rather than current package claims. Storage is treated as an intertemporal network device, not as a sequence of independent power injections. A multi-step solve co-optimizes the complete @@ -49,38 +68,40 @@ terminal state; the causal greedy controllers are terminal-blind. Their lower dispatchable-energy totals are not improvements where they accompany unserved load.* -Because it is built on CVXPY, the problem structure is transparent and -composable. Researchers can modify objectives, add contingency constraints, -or experiment with formulations — including multi-forecast Model Predictive -Control — without rewriting solver interfaces. +Because it is built on CVXPY, the mathematical structure is transparent and +composable. Researchers can add device models, objectives, and operating +constraints or study alternative network formulations without rewriting +solver interfaces. ## Overview `cvxopf` formulates optimal power flow problems using CVXPY and solves them with appropriate solvers. It is designed to: -- Run MATPOWER/Pypower test cases out of the box -- Support multiple OPF formulations from a single entry point -- Support single-shot optimization over multiple time steps -- Accept time-varying nodal load as pandas DataFrames +- Run MATPOWER/Pypower test cases out of the box. +- Support multiple OPF formulations from a single entry point. +- Support single-shot optimization over multiple time steps. +- Accept time-varying nodal load as pandas DataFrames. - Model storage as a first-class intertemporal device with state-of-charge - coupling and configurable terminal policies + coupling and configurable terminal policies. - Model nondispatchable generators (wind, solar, run-of-river hydro) with - curtailable output and reactive power support + curtailable output and reactive power support. - Model loads as first-class, identity-aligned devices with optional - single-solve shedding and energy-not-served reporting + single-solve shedding and energy-not-served reporting. - Coordinate long-horizon convex battery planning with audited short-horizon - AC execution through the public hierarchical controller + AC execution through the public hierarchical controller. ### Methodology Many individual capabilities exposed by `cvxopf`, including multi-period OPF and intertemporal storage, also appear in other power-system optimization packages. The central contribution here is their organization within a -[disciplined convex programming (DCP)](https://www.cvxpy.org/tutorial/dcp/) and [disciplined nonlinear programming -(DNLP)](https://www.cvxpy.org/tutorial/dnlp/index.html) methodology: device dynamics, costs, and operating sets remain convex -wherever the model permits, while the nonconvexity of the full AC formulation -is confined to the network-flow physics. +[disciplined convex programming (DCP)](https://www.cvxpy.org/tutorial/dcp/) +and [disciplined nonlinear programming +(DNLP)](https://www.cvxpy.org/tutorial/dnlp/index.html) methodology. Device +dynamics, costs, and operating sets remain convex wherever the model permits, +while the nonconvexity of the full AC formulation is confined to the +network-flow physics. This separation supports the implemented hierarchical solve structure. A globally solvable, long-horizon convex layer determines intertemporal energy @@ -186,7 +207,7 @@ bus: no branch flows, no transmission limits, no losses, no reactive power — just total generation equals total load. It is the classic economic dispatch problem, useful as a fast baseline and for large-horizon energy planning. -### Hierarchical DC to AC control +### Hierarchical DC-to-AC control `solve_hierarchical_opf()` implements the project's reviewed two-layer workflow. The outer `lossy_dc` problem plans the full remaining horizon. Each @@ -246,10 +267,10 @@ failure, and provenance contracts. References: - AC OPF: *Disciplined Nonlinear Programming*, - https://stanford.edu/~boyd/papers/dnlp.html, - https://github.com/cvxgrp/dnlp-examples/blob/main/nlp_examples/power_flow.ipynb + [paper](https://stanford.edu/~boyd/papers/dnlp.html) and + [power-flow example](https://github.com/cvxgrp/dnlp-examples/blob/main/nlp_examples/power_flow.ipynb). - Lossy DC OPF: *Convex Optimization with Smart Grid Examples*, - https://doi.org/10.2172/3018252 + [technical report](https://doi.org/10.2172/3018252). ## Prerequisites @@ -257,6 +278,7 @@ References: installed before running `pip install cvxopf`. **Ubuntu / Debian** + ```bash sudo apt-get update sudo apt-get install -y coinor-libipopt-dev liblapack-dev libblas-dev gfortran @@ -269,11 +291,13 @@ sudo apt-get install -y coinor-libipopt-dev liblapack-dev libblas-dev gfortran > with a linker error (`cannot find -llapack`, `cannot find -lblas`). **macOS** + ```bash brew install ipopt ``` **Windows** (conda recommended) + ```bash conda install -c conda-forge ipopt ``` @@ -440,8 +464,8 @@ and OPF configurations. The results should look something like this: ## Multi-step example -Time-varying load is passed as a DataFrame — one row per timestep, one -column per bus. This is the foundation for resiliency studies: feed in +Time-varying load is passed as a DataFrame — one row per time step, one +column per bus. This is the foundation for resilience studies: feed in a multi-day solar and load profile and the optimizer plans dispatch across the full horizon in a single solve. @@ -548,9 +572,9 @@ and [`case9_multistep_load_shedding.py`](examples/case9_multistep_load_shedding. ## Battery storage example -Battery state-of-charge evolves across timesteps, coupling decisions made +Battery state of charge evolves across time steps, coupling decisions made at hour 1 to feasibility at hour 72. This intertemporal coupling is why -multi-step optimization matters for resiliency: the optimizer can see that +multistep optimization matters for resilience: the optimizer can see that conditions worsen on day 3 and hold reserves accordingly rather than depleting storage on day 1. @@ -712,12 +736,16 @@ src/cvxopf/ Core package storage.py Storage component: data, injections, constraints, cost nondispatchable.py ND component: data, injections, and constraints hvdc.py HVDC component and MATPOWER dcline conversion + load.py Fixed and explicitly sheddable load component + hierarchical.py Hierarchical DC-to-AC controller and audit records testcases/ Built-in MATPOWER test cases (case9 — case118) tests/ Pytest test suite tests/fixtures/ Committed Pypower reference outputs (static) scripts/ Fixture and test case generation scripts notebooks/ Interactive marimo notebooks examples/ Runnable example scripts +experiments/ Reviewed scientific studies and retained protocols +plans/ Milestone plans and implementation records ``` ## Development @@ -793,7 +821,7 @@ package environment. - [x] Single-node equivalent "copper plate" model - [ ] SOCP network model - [x] Extend battery parameters: terminal equality/shortfall constraints and linear/quadratic terminal costs -- [ ] Implement cvxpy parameters for problem data +- [ ] Extend CVXPY parameterization for faster repeated solves - [ ] M14 time-vectorized multistep formulations: add a time-last tensor assembly mode alongside the retained stepwise CVXPY builder, with explicit canonicalization-backend selection and shared formulation/result semantics. @@ -822,3 +850,7 @@ package environment. nonuniqueness and local-solver selection, then add only scientifically justified AC operating preferences (see `plans/milestone-20-ac-voltage-reactive-regularization.md`) +- [ ] Nonconvex load-group penalties: model interactions such as mutually + exclusive customer-group shedding using relaxation, deterministic rounding, + and fixed-policy polishing (see + `plans/milestone-22-nonconvex-load-group-penalties.md`) diff --git a/experiments/ecosystem_positioning/PYPSA_CVXOPF_COMPARISON.md b/experiments/ecosystem_positioning/PYPSA_CVXOPF_COMPARISON.md new file mode 100644 index 0000000..a2489d5 --- /dev/null +++ b/experiments/ecosystem_positioning/PYPSA_CVXOPF_COMPARISON.md @@ -0,0 +1,635 @@ +# PyPSA and CVXOPF: compare and contrast + +**Review date:** 2026-08-26 + +## Purpose + +This document compares PyPSA and CVXOPF based on their current documented +capabilities and design centers. It focuses on the questions relevant to +long-horizon storage, rare and compound resilience events, generator cost +representation, price inputs, network fidelity, and computational scale. + +The two packages are not interchangeable competitors. PyPSA is a mature, +large-scale energy-system planning platform centered on linearized network +optimization. CVXOPF is a newer OPF research framework centered on a common +component model across a network-fidelity ladder, including nonlinear AC +optimization and hierarchical long-horizon-to-AC realization. + +That distinction becomes more important under black-sky conditions. Linear +approximations are often most trustworthy near the intact operating regimes +for which they were designed. Severe outages, unusual transfer patterns, +reactive-power scarcity, and operation near voltage or thermal boundaries can +move the system precisely where omitted AC interactions determine whether an +otherwise attractive plan is physically realizable. + +## Executive summary + +| Question | PyPSA | CVXOPF | +|---|---|---| +| Primary design center | Large-scale energy-system planning and dispatch | Multi-fidelity OPF and resilience-method research | +| Basic scaling formulation | Sparse LP with linearized network physics | Convex coarse planning plus selected nonlinear AC realization | +| Other optimization classes | QP, MILP, and piecewise formulations when enabled | Convex QP and nonconvex DNLP; future convex relaxations planned | +| Full nonlinear AC optimization | No; nonlinear power flow is available after optimization | Yes; nonlinear AC-OPF through CVXPY DNLP/IPOPT | +| Role of AC under severe stress | Post-optimization feasibility evaluation at a selected dispatch | Re-optimizes dispatch, reactive support, and voltage state inside the nonlinear AC feasible set | +| Long-horizon storage | Mature and scalable | Implemented, with explicit terminal policies and hierarchical AC handoff | +| Capacity expansion | Mature, including multi-investment periods | Not yet a general planning layer | +| Generator operating costs | Linear, quadratic, and recent PWL support | Polynomial and PWL MATPOWER-style cost curves | +| Time-varying price/cost inputs | First-class static or snapshot-indexed component data; often used as reduced operating signals | Generator cost curves and physical consequences are primary; no external electricity-price series is required | +| Endogenous nodal prices | Yes, as balance-constraint duals | Available in principle for convex formulations; not the central public result contract discussed here | +| Network-fidelity ladder | Linearized optimization followed optionally by nonlinear power flow | Single-node DC, networked lossy DC, and nonlinear AC-OPF under one component architecture | +| Rare-event uncertainty | Native two-stage stochastic planning and scenario workflows | Proposed batched scenario and hierarchical realization workflow; not yet a general stochastic-planning API | +| Demonstrated scale | Large networks, long horizons, and capacity expansion | Case118 month-scale hierarchy; annual scaling work remains active | + +## 1. Different design centers + +### PyPSA + +PyPSA is designed to co-optimize energy-system operation and investment across +many snapshots, technologies, carriers, and network locations. Its documented +problem classes include economic dispatch, Linear Optimal Power Flow (LOPF), +security-constrained LOPF, capacity-expansion planning, two-stage stochastic +optimization, and modeling-to-generate-alternatives. + +These models build on a sparse linearized network representation. Depending on +the supplied data and features, `Network.optimize()` constructs an LP, QP, or +MILP. The ordinary continuous model with linear marginal costs is an LP. +[PyPSA optimization overview](https://docs.pypsa.org/latest/user-guide/optimization/overview/) + +### CVXOPF + +CVXOPF is designed to express device physics once and use those devices across +multiple network formulations: + +- full nonlinear AC-OPF; +- a convex networked lossy-DC planning model; and +- convex single-node economic dispatch. + +Its central research use is to connect long-horizon energy planning with +shorter high-fidelity AC realization through shared physical state, especially +battery state of charge. See the local [README](../../README.md) and +[software architecture](../../PROJECT_FLOWCHART.md). + +The AC layer is not included merely to refine ordinary-condition power-flow +accuracy. It lets the realization choose a different active/reactive dispatch +and voltage state when a coarse plan encounters damaged or highly stressed +network physics. + +CVXOPF does not currently match PyPSA's breadth of sector coupling, investment +planning, ecosystem maturity, or demonstrated scale. + +## 2. The basic PyPSA scaling approach is an LP + +The canonical PyPSA formulation is Linear Optimal Power Flow. With continuous +variables, linear device constraints, linearized network equations, and +constant linear marginal costs, the complete dispatch or capacity-expansion +problem is a sparse LP: + +$$\text{linearized network physics} + \text{linear device constraints} + \text{linear cost} \longrightarrow \text{LP}.$$ + +PyPSA's cycle-based KVL formulation is chosen in part for sparse computational +performance. Nonlinear AC power flow can be run after optimization, but this +does not convert the multi-period planning problem into nonlinear AC-OPF. +[PyPSA optimization API](https://docs.pypsa.org/latest/api/networks/optimize/) + +Current PyPSA is not exclusively linear: + +- quadratic marginal costs produce a QP; +- unit commitment and modular investments can produce a MILP; and +- piecewise relationships can use LP, incremental, SOS2, or disjunctive + formulations. + +Those features extend an architecture whose characteristic large-scale path +remains LP-centered. + +## 3. Network physics + +### PyPSA optimization + +PyPSA's standard network optimization uses linearized active-power network +constraints. This is appropriate for large-scale planning, market, and +capacity-expansion studies in which tractability across many nodes and +snapshots is the principal requirement. + +PyPSA can subsequently run nonlinear power flow on an optimized dispatch. That +post-processing step can identify voltage or reactive-power issues, but it is +not the same as optimizing the dispatch subject to the nonlinear AC feasible +set. + +### CVXOPF fidelity ladder + +CVXOPF exposes three current formulations: + +1. **Single-node DC:** aggregate active-power balance with no network, + congestion, voltage, reactive power, or transmission loss. +2. **Lossy DC:** convex network-aware active-power planning with nodal balance, + branch limits, device location, and a resistance-weighted quadratic flow + penalty. Its nodal conservation remains lossless; the loss term is a proxy + or regularizer rather than physical branch-loss withdrawal. +3. **AC:** nonlinear voltage-magnitude and angle variables, active and reactive + nodal balance, fixed transformer data, and two-terminal apparent-power + branch limits. + +The AC formulation is nonconvex and solved locally with IPOPT. An accepted +solution is not a global-optimality certificate. + +### Why AC optimization matters for black-sky events + +Access to the nonlinear AC formulation is particularly valuable when the +system is far from its ordinary operating regime. Large, geographically +bounded outages can change transfer paths, reactive-power availability, +voltage support, losses, and which terminal of a branch is thermally limiting. +High load and equipment derating can place the system near voltage and +apparent-power boundaries that an active-power linearization does not model. + +The distinction between nonlinear power flow and nonlinear AC-OPF is central: + +- **Post-optimization power flow** asks whether one previously selected + dispatch has an AC solution. +- **AC-OPF realization** searches for a different dispatch, reactive + allocation, and voltage state that satisfies the AC equations while meeting + the modeled operating objective and constraints. + +Thus, a coarse plan that fails a nonlinear power-flow check is not necessarily +physically impossible. It may require redispatch, reactive support, load +service changes, or a different use of storage. Conversely, a plan that looks +adequate under aggregate or linear active-power constraints may fail because +the damaged network lacks voltage support, reactive capability, or +two-terminal apparent-power headroom. + +It is more accurate to say that CVXOPF represents the full nonlinear AC-OPF +feasible set than to say that it exhaustively accesses the entire AC solution +space. IPOPT is a local solver; initialization and local nonconvex geometry +still matter. CVXOPF's causal warm-start recovery and independent residual +audits address operational robustness and scientific interpretation, but do +not create a global certificate. + +AC-OPF is also not a complete blackout or cascading-failure simulator. The +current quasi-steady-state model does not replace transient stability, +protection, frequency, electromagnetic, unbalanced distribution, or cascading +outage analysis. Its contribution is narrower and still important: it tests +and optimizes steady-state active/reactive network feasibility during the +consequential portions of a long event history. + +## 4. Generator costs and the duck curve + +### Constant linear cost + +Suppose one dispatchable generator has cost + +$$C(P_t)=cP_t.$$ + +Moving one MWh of production from a high-output hour to a low-output hour does +not change generation cost: + +$$c(P_{\mathrm{low}}+1)+c(P_{\mathrm{high}}-1)=cP_{\mathrm{low}}+cP_{\mathrm{high}}.$$ + +If storage is lossy, the shift may increase total cost. A model with one +constant linear marginal generator cost therefore has no inherent reason to +level that generator's output unless storage also: + +- crosses into a different generator's merit-order block; +- avoids renewable curtailment or spillage cost; +- relieves congestion; +- avoids a capacity, ramping, reserve, or reliability constraint; or +- serves another explicit objective term. + +This is not a storage-model defect. It is the economic consequence of a flat +marginal-cost objective. + +### Convex output-dependent cost + +For a quadratic generator cost, + +$$C(P_t)=c_0+c_1P_t+c_2P_t^2,\qquad c_2>0,$$ + +the marginal cost rises with output: + +$$C'(P_t)=c_1+2c_2P_t.$$ + +Storage can then reduce total operating cost by shifting production from a +high-marginal-cost hour to a low-marginal-cost hour, subject to efficiency, +network, power, energy, and terminal constraints. Levelization emerges from +the system-cost model rather than from an imposed price trajectory. + +A convex PWL cost curve produces the same qualitative effect when storage +moves dispatch between segments with different slopes. + +### PyPSA cost capabilities + +PyPSA's standard generator data support: + +- static or time-varying linear `marginal_cost`; +- static or time-varying `marginal_cost_quadratic`; and +- recent native PWL marginal-cost curves. + +The current documented PWL generator operating-cost interface applies to +fixed, non-extendable generator capacity. Depending on the curve and selected +formulation, the representation may remain an LP or may require a stronger +piecewise formulation. +[PyPSA piecewise documentation](https://docs.pypsa.org/latest/user-guide/optimization/piecewise/) + +Consequently, it is no longer accurate to say that every current PyPSA model +is restricted to one linear marginal cost per generator. It is accurate to say +that constant linear generator costs are the common and simplest LP-centered +configuration, and that this configuration may not create an endogenous +incentive to level output within one generator's range. + +### CVXOPF cost capabilities + +CVXOPF treats polynomial and PWL MATPOWER-style generator curves as native OPF +data. The scientific specification can therefore assign output-dependent +generation cost without supplying an external hourly electricity-price +trajectory. + +CVXOPF still minimizes the declared objective; it does not flatten net load +for aesthetic reasons. If load leveling itself is the scientific objective, +the model should include an explicit convex peak, ramp, variance, or deviation +penalty. + +## 5. Prices as inputs and outputs + +### PyPSA + +Exogenous price-like quantities are first-class PyPSA inputs. Component +`marginal_cost` may be static, snapshot-indexed, or in supported cases +piecewise. It enters the objective directly for generators, storage units, +stores, links, and processes. + +PyPSA's `Store` documentation explicitly identifies external-market trading +prices as one use of signed store marginal cost. PyPSA's stochastic example +also represents gas-price uncertainty through scenario-dependent input costs. +[PyPSA objective](https://docs.pypsa.org/latest/user-guide/optimization/objective/), +[Store component](https://docs.pypsa.org/latest/user-guide/components/stores/), +[stochastic example](https://docs.pypsa.org/latest/examples/stochastic-optimization/) + +PyPSA also produces endogenous bus marginal prices as dual values of nodal +balance. Therefore: + +| Quantity | PyPSA role | +|---|---| +| Generator fuel or offer price | First-class cost input | +| External-grid purchase or sale price | First-class input through an appropriate component | +| Time-varying price forecast | First-class snapshot-indexed input | +| Scenario-dependent commodity price | First-class stochastic parameter | +| Bus locational marginal price | Endogenous optimization output | + +PyPSA does not require an external electricity-price time series for every +solve. It does make such time series ordinary, well-supported model data. + +### CVXOPF + +CVXOPF's current resilience studies are built from physical and economic +primitives: + +- generator cost curves; +- load and renewable availability; +- network limits and losses or loss proxies; +- storage efficiency, cycling cost, and terminal policy; +- load-shedding cost; and +- the evolving system state. + +This is useful for black-sky studies because a historical or forecast market +price may be unavailable or scientifically inappropriate after widespread +damage. Storage value can emerge from the modeled damaged system rather than +from a speculative price path. + +### Prices as compressed system models + +For system planning, an exogenous price trajectory is often being used as a +linear surrogate for a much larger omitted value function. Let $x$ denote a +battery or other flexible-resource decision and let $y$ contain the +remaining network, generation, reliability, and recovery decisions. The full +system value of $x$ is + +$$V(x)=\min_y\left\{f(x,y)\;\middle|\;g(x,y)=0,\;h(x,y)\leq 0\right\}.$$ + +A price-driven model commonly substitutes + +$$V(x)\approx \sum_t p_t x_t.$$ + +At best, $p_t$ is a local derivative of the full value function at one +operating point: + +$$p_t \approx \frac{\partial V}{\partial x_t}.$$ + +It is not generally the value function itself. The substitution assumes that +system value is sufficiently linear, temporally separable, spatially resolved, +and unaffected by the optimized response. It suppresses curvature and +cross-interactions such as + +$$\frac{\partial^2 V}{\partial x_t^2},\qquad \frac{\partial^2 V}{\partial x_t\partial x_{t+k}},\qquad \frac{\partial^2 V}{\partial x_{n,t}\partial x_{m,s}},$$ + +which can encode increasing marginal generation cost, energy coupling, +congestion, shared reserves, recovery bottlenecks, and sequential-event +dependence. + +This approximation can be reasonable for a small price-taking participant +under ordinary market conditions. It becomes weaker when the flexible +resource is large enough to change dispatch, congestion, scarcity, or the +identity of the marginal generator. In that case the resource changes the +prices against which it is being optimized, violating the fixed-price +assumption. + +The distinction is especially important in black-sky studies. A historical +price series was generated by a different network state, asset fleet, market +design, and damage condition. Asking it to represent widespread outages, +physical scarcity, customer consequences, and months of recovery implicitly +asks an external scalar signal to reconstruct interactions omitted from the +model. + +Endogenous prices remain scientifically useful. In a convex system model, +dual variables report local marginal values of explicit constraints and can +support decentralized coordination. However, they: + +- are local to the solved operating point; +- change when the active set changes; +- inherit every omission in the underlying model; +- do not automatically value unmodeled resilience consequences; and +- may not support a nonconvex or discrete system optimum through linear prices + alone. + +The preferred scientific ordering for CVXOPF resilience studies is therefore + +```text +physical resources, constraints, consequences, and state + | + v + optimized operation + | + v + endogenous marginal values +``` + +The methodological claim is not that prices are unusable. It is that a price +is a local shadow value derived from a model, not a substitute for physical +and intertemporal interactions that should be represented explicitly when +they determine the resilience conclusion. + +## 6. Storage and intertemporal operation + +### PyPSA strengths + +PyPSA has mature intertemporal storage models, including asymmetric charging +and discharging efficiencies, standing losses, inflow, spillage, cyclic state +conditions, and extendable power or energy capacity depending on the selected +component representation. + +It is well suited to long-horizon storage dispatch and investment studies when +linearized network physics is appropriate. + +### CVXOPF strengths + +CVXOPF currently provides an ideal storage device with: + +- active/reactive operating limits in AC; +- active-power bounds in DC; +- explicit state-of-charge dynamics; +- cycling cost; +- hard equality or reserve-floor terminal constraints; +- linear or quadratic, one- or two-sided terminal penalties; and +- stable identity for state handoff across separately built problems. + +A lossy-storage milestone is planned. PyPSA already ships important lossy +storage capabilities, so lossy storage alone is not a CVXOPF differentiator. + +CVXOPF's distinctive emphasis is using a long-horizon convex storage plan to +coordinate audited rolling AC-OPF realization without requiring the AC +dispatch to reproduce the coarse dispatch trajectory exactly. + +## 7. Long horizons and compound events + +Both packages can represent storage state across long time horizons. CVXOPF's +research thesis emphasizes long horizons as the technical enabler for compound +events: + +```text +event 1 + -> damage and operating response + -> partial recovery and resource consumption + -> event 2 + -> compound consequence +``` + +The relevant carried state may include storage energy, asset availability, +repair progress, fuel or spare inventories, and supply-chain delays. + +PyPSA has the more mature large-scale planning substrate for expressing long +sequences and investment decisions. CVXOPF has the higher-fidelity nonlinear +AC realization layer and explicit hierarchical state-handoff machinery. A +future scientific workflow could use either package independently or use +their ideas complementarily. + +For compound-event studies, these roles operate at different temporal scales. +The long convex trajectory preserves damage, recovery, inventory, and storage +state between events. Selected AC intervals then determine whether the system +can physically realize service and recovery decisions under the stressed +network. The AC intervals must inherit the long-horizon state; treating them +as independent snapshots would erase the compound-event mechanism. + +## 8. Uncertainty + +### PyPSA + +PyPSA documents native two-stage stochastic optimization in which investments +are first-stage decisions and dispatch is scenario-dependent recourse. It also +has established capacity-expansion and multi-investment-period machinery. + +This makes PyPSA materially ahead of CVXOPF for general stochastic investment +planning today. + +### CVXOPF + +CVXOPF does not yet provide a general public stochastic-programming or +capacity-expansion API. The proposed rare-event workflow is: + +1. generate spatially and temporally correlated event ensembles; +2. batch or parallelize compatible convex single-node or lossy-DC scenarios; +3. screen portfolios and tail outcomes; +4. retain persistent state across compound events; and +5. realize consequential intervals through audited nonlinear AC-OPF. + +This last step is not merely a higher-resolution plot. It can change which +portfolios or policies remain acceptable when the uncertainty ensemble +contains unusual topology, geographically concentrated damage, reactive +scarcity, or near-limit transfers. + +The potential Moreau backend is an investigation, not a current dependency or +demonstrated CVXOPF capability. Its relevance is GPU-batched solution of +structurally identical convex event ensembles, not nonlinear AC-OPF. + +## 9. Investment planning + +PyPSA can co-optimize generation, storage, conversion, and transmission +capacity, including multiple investment periods. This is a core capability. + +CVXOPF can currently evaluate prescribed device fleets and candidate +portfolios. Fully optimizing siting, sizing, construction, hardening, +contracting, or repair inventory requires a new planning layer. Continuous +sizing may fit a convex outer formulation; discrete decisions may require +mixed-integer optimization or relax--round--polish. + +Any external comparison should state this asymmetry plainly. + +## 10. Computational scale + +### PyPSA + +PyPSA's LP-centered approach, Linopy implementation, and mature solver +interfaces are designed for large spatial and temporal models. Its established +use cases include national and continental energy-system studies. + +### CVXOPF + +CVXOPF deliberately pays more for physical fidelity. Nonlinear multistep AC +graphs become expensive in construction, memory, and solve time. The current +scaling program includes: + +- vectorizing time-indexed model construction; +- coarse-to-fine formulation hierarchy; +- causal warm-start and recovery policies; +- supervised process recycling; and +- parallel temporal decomposition of selected AC realization intervals. + +The demonstrated Case118 hierarchy has reached month scale. Annual and +multi-year network studies remain development goals rather than completed +capabilities. + +## 11. Solver guarantees and audits + +PyPSA LPs and convex QPs can be solved to global optimality within solver +tolerances. MILPs provide global bounds and, when completed, optimality gaps. +Results still depend on model validity, input uncertainty, and numerical +conditioning. + +CVXOPF's convex formulations likewise have global convex guarantees when +accepted. Its AC formulation is nonconvex; IPOPT returns local solutions or +failures, not global certificates. CVXOPF therefore retains independent +physical residual audits and has developed causal initialization-recovery +policies for sequential AC operation. + +In one controlled branch-limit-neutralized case, cross-evaluation established +that a CVXOPF solution was feasible in the matched Pypower problem and at +least 14.3% cheaper than Pypower's returned point. This proves that particular +Pypower point was suboptimal; it does not prove CVXOPF's point globally +optimal or establish a universal superiority claim. + +## 12. When each package is the more natural choice + +### Prefer PyPSA when the primary question is + +- national or continental capacity expansion; +- sector-coupled energy-system planning; +- many investment periods; +- large stochastic planning models; +- mature LP/MILP workflows; or +- broad technology and carrier coverage under linearized network physics. + +### Prefer CVXOPF when the primary question is + +- whether a long-horizon plan is realizable under nonlinear AC physics; +- resilience or black-sky operation far from an intact-system linearization; +- active/reactive power, voltage, and apparent-power behavior during critical + periods; +- formulation research across single-node, network-DC, and AC models; +- storage terminal-value and state-handoff questions; +- hierarchical convex-planning-to-AC control; or +- controlled study of DNLP canonicalization and nonlinear local-solver + behavior. + +### A complementary workflow + +A future combined workflow could use PyPSA for mature large-scale investment +planning and CVXOPF for selected nonlinear AC realization. Such a coupling +would require explicit identity, units, topology, state, and acceptance +contracts; it should not be assumed to be automatic. + +## 13. Claims that are supported + +- PyPSA's basic scaling path is a sparse LP using linearized network physics. +- Current PyPSA can also formulate QPs, MILPs, and piecewise models. +- Exogenous marginal-cost and price time series are first-class PyPSA inputs. +- PyPSA also reports endogenous nodal marginal prices. +- An exogenous price trajectory is a reduced linear signal, not a complete + representation of the system value function that generated it. +- Endogenous dual prices are useful local diagnostics but inherit the scope, + assumptions, and omissions of their underlying model. +- Constant linear generator costs may provide no incentive to level output + within one generator's dispatch range. +- Quadratic or convex PWL generator costs can create endogenous temporal value + for storage without an external electricity-price series. +- CVXOPF natively optimizes nonlinear AC physics and uses convex formulations + for longer-horizon coordination. +- AC-OPF realization can redispatch within the nonlinear feasible set; a + post-optimization nonlinear power flow evaluates only the supplied dispatch. +- PyPSA is substantially more mature for capacity expansion and large-scale + stochastic planning. +- CVXOPF is substantially more specialized around nonlinear AC realization + and a common multi-fidelity component architecture. + +## 14. Claims to avoid + +- **Avoid:** "PyPSA cannot model storage over time." + It has mature intertemporal storage and investment models. +- **Avoid:** "PyPSA can only solve LPs." + LP is the basic path, but current PyPSA also supports QP, MILP, and PWL + formulations. +- **Avoid:** "PyPSA requires an electricity-price series." + It does not. Price and marginal-cost series are first-class optional inputs. +- **Avoid:** "A supplied price series faithfully preserves omitted network, + reliability, and recovery interactions." + It is at most a reduced, regime-dependent signal from another system model. +- **Avoid:** "PyPSA cannot represent output-dependent generator costs." + Current versions support quadratic and recent PWL operating costs. +- **Avoid:** "CVXOPF already scales better than PyPSA." + It does not; PyPSA has the stronger demonstrated large-scale planning record. +- **Avoid:** "CVXOPF AC solutions are globally optimal." + They are accepted local nonlinear solutions. +- **Avoid:** "Lossy storage differentiates CVXOPF from PyPSA." + PyPSA already supports asymmetric efficiency and standing loss. +- **Avoid:** "The two tools answer the same scientific question." + Their current design centers and fidelity--scale tradeoffs differ. + +## 15. Bottom line + +PyPSA scales by keeping the core planning problem sparse and usually linear. +That is a major strength, especially for investment, stochastic, and +sector-coupled studies. Recent QP and PWL features reduce the limitations of a +constant-linear-cost model without changing PyPSA's overall planning focus. + +CVXOPF is pursuing a different compromise: retain a common scientific model +across coarse convex formulations and full nonlinear AC-OPF, then use +hierarchy and temporal decomposition to spend AC fidelity only where it can +change the conclusion. + +That selective AC access is especially relevant to resilience. Severe damage +and compound stress can invalidate ordinary-condition assumptions precisely +when voltage, reactive power, losses, and apparent-power limits become +decision-determining. The hierarchy is intended to preserve years of state +without paying for years of AC solves, while still allowing the critical +intervals to be re-optimized inside the nonlinear AC formulation rather than +merely checked at a fixed coarse dispatch. + +For unprecedented rare and compound events, CVXOPF's intended advantage is +not that it forbids price inputs. It is that storage and reliability value can +be derived from physical scarcity, output-dependent production costs, network +constraints, damage and recovery state, load-shedding consequences, and +terminal obligations without requiring a speculative hourly market-price +trajectory. + +From a physics and mathematical perspective, an imported price trajectory +attempts to summarize interactions that have been left outside the model. The +more strongly a decision changes those interactions, the less defensible the +fixed-price approximation becomes. CVXOPF's resilience direction is to model +the consequential interactions explicitly and treat marginal values as +outputs of that model wherever possible. + +## Primary external sources + +- [PyPSA optimization overview](https://docs.pypsa.org/latest/user-guide/optimization/overview/) +- [PyPSA optimization objective](https://docs.pypsa.org/latest/user-guide/optimization/objective/) +- [PyPSA piecewise constraints](https://docs.pypsa.org/latest/user-guide/optimization/piecewise/) +- [PyPSA generator component](https://docs.pypsa.org/stable/user-guide/components/generators/) +- [PyPSA storage-unit component](https://docs.pypsa.org/latest/user-guide/components/storage-units/) +- [PyPSA store component](https://docs.pypsa.org/latest/user-guide/components/stores/) +- [PyPSA stochastic-optimization example](https://docs.pypsa.org/latest/examples/stochastic-optimization/) +- [PyPSA optimization API](https://docs.pypsa.org/latest/api/networks/optimize/) diff --git a/plans/milestone-22-nonconvex-load-group-penalties.md b/plans/milestone-22-nonconvex-load-group-penalties.md new file mode 100644 index 0000000..c08e6e7 --- /dev/null +++ b/plans/milestone-22-nonconvex-load-group-penalties.md @@ -0,0 +1,418 @@ +# Milestone 22 — Nonconvex load-group penalties + +**Status:** planned + +**Depends on:** Milestone 19 (first-class loads and load shedding), Milestone +16+ (typed component contribution and shared assembly contracts) + +**Related to:** Milestone 17 (hierarchical DC/AC realization), Milestone 18 +(relax–round–polish for non-ideal storage), and Milestone 21 (configurable +formulation hierarchies) + +## 1. Goal + +Add scientifically explicit policies for interactions among groups of +sheddable loads when the desired rule is nonconvex. The reference policy is: + +> Load group A or load group B may be shed as a last resort, but both groups +> may not be shed in the same decision interval. + +The primary solution strategy is **relax–round–polish**: + +1. solve a bounded convex-hull or McCormick relaxation; +2. convert the relaxed group decisions into an admissible discrete policy; +3. fix that policy and polish the continuous OPF; and +4. independently audit the polished physical solution. + +The milestone must work first in the convex single-node and lossy-DC +formulations and then support fixed-policy AC polishing. It must not require a +mixed-integer solver for ordinary use. Small mixed-integer or enumerated +problems may be retained as scientific reference oracles. + +This milestone does not claim that every nonconvex customer policy has a +useful convex relaxation. It establishes one typed, auditable pattern and +measures when that pattern succeeds or fails. + +## 2. Scientific questions to freeze before implementation + +The experiment protocol must distinguish the following questions rather than +allowing an API default to answer them implicitly. + +### 2.1 Meaning of a group + +A group is an identified set of existing `Load.device_id` values. Membership +must be explicit, stable, unique within the policy, and independent of list +position. Decide whether overlapping groups are forbidden in the first +implementation; the recommended initial contract forbids them. + +Negative active loads are fixed net injections under M19 and are not eligible +shedding capacity. Zero and reactive-only loads likewise contribute zero +active shedding capacity. + +### 2.2 Scope of exclusivity + +These are different policies: + +- **per interval:** A or B may be shed at each time, and the selected group may + change between intervals; +- **per event/window:** one group is selected for the complete event; +- **block or minimum-duration:** selection may change, but only at declared + boundaries or after a minimum dwell time; and +- **priority rather than exclusivity:** one group should be exhausted before + the other, but both may be shed if adequacy requires it. + +The reference implementation should begin with per-interval and whole-window +exclusivity. Switching costs, dwell constraints, and priority policies should +be added only with separate names and tests. + +### 2.3 Hard rule versus soft penalty + +Do not conflate: + +1. the hard complementarity rule + + \[ + S_{A,t}S_{B,t}=0, + \] + + with + +2. a positive joint-shedding penalty + + \[ + \kappa_t S_{A,t}S_{B,t}. + \] + +The first prohibits simultaneous shedding. The second permits it at a cost +and may be preferable when strict exclusivity would create artificial +infeasibility. Both are nonconvex, but their relaxations, rounding rules, and +scientific interpretations differ. + +## 3. Reference group quantities + +For group \(g\) and interval \(t\), define aggregate active shedding + +\[ +S_{g,t}=\sum_{i\in g}s_{i,t} +\] + +and the synchronized upper bound + +\[ +U_{g,t}=\sum_{i\in g} +\max(P^{\mathrm{load}}_{i,t},0)\,f_i^{\max}. +\] + +The group model must reuse the M19 load variables and parameters. It must not +construct a second load-shedding decision or an independently updated copy of +load demand. + +Every aggregate and bound must remain inspectable by stable group and device +identity. Parameter updates must preserve the existing atomic positive/zero/ +negative load semantics. + +## 4. Convex-hull relaxation for exclusive groups + +Introduce a selector \(z_t\). The exact disjunction is + +\[ +z_t\in\{0,1\}, +\qquad +0\leq S_{A,t}\leq U_{A,t}z_t, +\qquad +0\leq S_{B,t}\leq U_{B,t}(1-z_t). +\] + +Relaxing \(z_t\in[0,1]\) gives the convex hull of the bounded two-group +disjunction for one interval. Equivalently, when both upper bounds are +positive, + +\[ +\frac{S_{A,t}}{U_{A,t}}+ +\frac{S_{B,t}}{U_{B,t}}\leq1. +\] + +Use the extended selector formulation because it exposes the quantity that +must be rounded and handles synchronized bounds without division by a zero +parameter. Zero-capacity groups require explicit deterministic behavior, not +an epsilon denominator. + +For convex single-node and lossy-DC problems, the relaxed objective is a valid +lower bound on the corresponding exact disjunctive optimum when all other +model assumptions match. Do not describe an AC relaxed or polished local +solution as a global bound. + +## 5. McCormick relaxation for a soft interaction penalty + +For the soft product \(w_t=S_{A,t}S_{B,t}\), use finite synchronized bounds +and the complete McCormick envelope. For nonnegative group shedding, + +\[ +\begin{aligned} +w_t &\geq 0,\\ +w_t &\geq U_{A,t}S_{B,t}+U_{B,t}S_{A,t}-U_{A,t}U_{B,t},\\ +w_t &\leq U_{A,t}S_{B,t},\\ +w_t &\leq U_{B,t}S_{A,t}. +\end{aligned} +\] + +The relaxed objective may include \(\Delta\sum_t\kappa_t w_t\). The plan must +record the units of \(\kappa_t\), whether it is a stage-cost rate, and how it +changes with time resolution. Terminal or event-level penalties must remain +outside the time integral when appropriate. + +The McCormick relaxation can be weak, especially when minimizing a positive +product over broad bounds. Report envelope slack and polished product cost; +do not present the relaxed auxiliary value as the realized interaction cost. + +## 6. Typed public and private contracts + +### 6.1 Group policy object + +Design an immutable typed object with, at minimum: + +- stable policy ID; +- ordered group IDs and their member `Load.device_id` values; +- policy kind: `exclusive` or `joint_penalty`; +- decision scope: `per_interval` or `whole_window` initially; +- optional time-aligned interaction weights; +- rounding-policy configuration; and +- explicit emergency or infeasibility policy. + +Do not overload `Load.shedding_cost_per_mwh`. Individual value-of-lost-load +costs and cross-group interaction policy are distinct model concepts. + +### 6.2 Relaxation and rounding records + +Retain typed records for: + +- relaxed selectors and group shedding; +- relaxation status, objective, bounds, and residuals; +- rounding inputs, deterministic rule, seed where applicable, and output; +- every polished candidate attempted; +- the accepted fixed group schedule; +- polished objective and independent residual audit; and +- explicit failure classification. + +Records must distinguish optimized quantities from post-solve evaluation +metrics. + +### 6.3 Component boundary + +Group interactions are constraints or costs over variables owned by multiple +`Load` objects. Determine during Stage 0 whether they belong in: + +- a typed load-fleet horizon contribution; or +- a small cross-component policy layer invoked after ordinary load assembly. + +Do not force a group policy into one individual load adapter, reconstruct load +variables, or add formulation-specific copies to all three builders. If M16+ +lacks a generic fleet-level interaction hook, complete that contract narrowly +and test it with another synthetic interaction. + +## 7. Rounding policies + +Rounding must be named, deterministic, and scientifically inspectable. The +initial candidates should include: + +1. **threshold:** choose A when \(z_t\geq\tau\), otherwise B; +2. **candidate polish:** near a declared ambiguity band, polish both fixed + alternatives and retain the best accepted result; +3. **whole-window enumeration:** solve A-only and B-only polished problems; +4. **block rounding:** choose one group over predeclared contiguous blocks; + and +5. **feasibility repair:** revise only failed or ambiguous blocks using a + deterministic, bounded candidate sequence. + +Do not silently switch to simultaneous shedding when exact exclusivity was +requested. If the policy permits an emergency third mode, name it explicitly, +assign its cost deliberately, and report its use. + +For per-interval policies, naive exhaustive enumeration scales as \(2^T\). +Small exhaustive cases are reference oracles only. Longer horizons should use +threshold/block rounding, dynamic programming where the temporal policy +allows it, or a separately configured mixed-integer oracle. + +## 8. Polishing and formulation hierarchy + +Polishing fixes the rounded group selection and rebuilds or updates the +continuous problem with the corresponding shedding bounds. The polish must: + +- use the original objective, physical constraints, and synchronized inputs; +- apply no residual penalty that changes the declared policy; +- pass the formulation's independent acceptance audit; and +- report infeasibility rather than substituting the relaxed solution. + +The reference hierarchical workflow is: + +```text +single-node or lossy-DC relaxation + | + v + deterministic rounding + | + v + fixed-policy convex polish and audit + | + v + fixed-policy AC realization +``` + +The AC layer consumes a fixed group schedule; it does not round. If AC polish +fails, try only a predeclared causal candidate sequence. An accepted alternate +proves the original rounded schedule was not required; repeated local failure +does not prove physical infeasibility without stronger evidence. + +## 9. Evaluation metrics + +At minimum, report: + +- active and reactive service by device and group; +- group energy not served; +- simultaneous relaxed shedding and its duration; +- selector fractionality and distance to the rounded schedule; +- relaxed, convex-polished, and AC-polished objectives; +- relaxation and rounding gaps where mathematically valid; +- group switches, dwell durations, and longest shedding event; +- number of candidate polishes and recovery attempts; +- solver, canonicalization, and total wall time; and +- all ordinary network, voltage, thermal, balance, and terminal-state audits. + +Renewable curtailment, storage throughput, congestion exposure, voltage +support, and recovery latency remain evaluation metrics unless a separately +named model explicitly prices or constrains them. + +## 10. Verification and scientific experiments + +### 10.1 Algebraic unit cases + +- Compare the selector formulation with the analytic convex hull. +- Exercise positive, zero, and time-varying group bounds. +- Verify complete McCormick inequalities at corners and interior points. +- Confirm stable identity alignment and reject missing, duplicate, or + overlapping memberships according to the frozen policy. +- Verify exact delta scaling of time-varying interaction penalties. + +### 10.2 Exact small reference study + +On a small single-node problem, enumerate every admissible group choice and +compare against: + +- the relaxed lower bound; +- each rounding policy; +- the fixed-choice polished optimum; and +- an optional pinned mixed-integer oracle. + +Use cases with zero gap, positive gap, ambiguous \(z\), and exact-policy +infeasibility. + +### 10.3 Network-location study + +Use a congested lossy-DC case where customer groups occupy different buses. +Show how transmission constraints change the selected group relative to the +single-node result. Separate customer priority from network deliverability. + +### 10.4 AC realization study + +Fix the rounded selection and solve the corresponding AC problem. Audit +active/reactive balance, voltage, branch limits, group service, and exact +exclusivity. Compare the AC realization with the convex plan without requiring +identical dispatch trajectories. + +### 10.5 Temporal-policy study + +Compare per-interval, whole-window, and block selection on a multistep event. +Measure switching, rounding gap, polished cost, customer-class ENS, and +runtime. Do not choose the preferred policy solely because it is easiest to +solve. + +## 11. Staged implementation plan + +### S0 — Freeze semantics and baselines + +- choose the reference customer groups and event; +- freeze membership, exclusivity scope, emergency behavior, and units; +- retain fixed-load and independent-shedding numerical baselines; +- decide the fleet-level architectural hook; and +- define acceptance residuals and result schemas before implementation. + +### S1 — Identity-aligned group objects and reporting + +- add the typed group-policy input without changing feasible sets; +- aggregate device shedding and capacity by stable identity; +- publish group service and ENS expressions; and +- cover empty, zero-capacity, negative-load, and reactive-only groups. + +### S2 — Exclusive convex-hull relaxation + +- add continuous selectors and bounded hull constraints; +- support per-interval and whole-window selectors; +- preserve single-node, lossy-DC, and AC builder architecture; and +- validate the relaxation against analytic and enumerated cases. + +### S3 — Typed rounding and fixed-policy polish + +- implement threshold, ambiguity-band candidate, and whole-window enumeration + policies; +- retain every candidate and audit; +- add deterministic feasibility repair; and +- establish relaxed-versus-polished reporting. + +### S4 — Soft joint-shedding penalty + +- implement the complete McCormick envelope; +- integrate time-varying penalty rates exactly once; +- report relaxed and realized product costs separately; and +- characterize relaxation strength across controlled bounds. + +### S5 — Lossy-DC and AC realization + +- demonstrate location-sensitive selection under congestion; +- consume fixed group schedules in AC; +- add formulation-specific physical audits; and +- classify planning mismatch separately from local-solver failure. + +### S6 — Temporal and hierarchical experiment + +- compare per-interval, block, and whole-event policies; +- evaluate rounding quality, switches, ENS allocation, runtime, and recovery; +- test convex planning followed by fixed-policy AC realization; and +- retain the complete reproducible experiment record. + +### S7 — Documentation and extension proof + +- document group-policy semantics and relax–round–polish limitations; +- add runnable single-node and hierarchical examples; +- show how a new cross-load penalty uses the same typed interaction boundary; +- document solver requirements for optional exact reference oracles; and +- update the architecture diagram without implying a general-purpose mixed- + integer plugin system. + +## 12. Completion gates + +Milestone 22 is complete when: + +1. group membership and all results align by stable load identity; +2. the exclusive relaxation matches the analytic convex hull and small exact + enumeration baselines; +3. rounding is deterministic, typed, and fully retained; +4. every accepted solution comes from a fixed-policy physical polish; +5. hard exclusivity and soft joint penalty remain separate public concepts; +6. convex lower-bound claims are made only where valid; +7. single-node, congested lossy-DC, and fixed-policy AC studies pass their + independent audits; +8. time-varying penalties obey the package's objective-time convention; +9. unsuccessful relaxed and polished solves retain stable result schemas; and +10. documentation reports relaxation limits, rounding gaps, and any emergency + policy use without presenting them as exact convex behavior. + +## 13. Explicit non-goals + +- a universal mixed-integer or complementarity solver interface; +- a claim of global optimality for AC polished solutions; +- arbitrary overlapping or nested customer-group logic in the first release; +- stochastic or adversarial customer selection; +- unit commitment, restoration sequencing, or distribution-network switching; +- hiding exact-policy infeasibility through unreported simultaneous shedding; +- treating every post-solve metric as an objective; or +- replacing customer-policy decisions with a single undifferentiated VOLL. diff --git a/plans/rare-event-uncertainty-and-resilience.md b/plans/rare-event-uncertainty-and-resilience.md new file mode 100644 index 0000000..c428480 --- /dev/null +++ b/plans/rare-event-uncertainty-and-resilience.md @@ -0,0 +1,594 @@ +# Rare-event uncertainty and long-range resilience planning + +## Purpose + +This note summarizes the proposed treatment of uncertainty for rare, +high-consequence resilience events. The objective is to use CVXOPF to identify +long-range investments and adaptive operating policies that remain effective +across uncertain event footprints, severities, durations, damage states, and +recovery trajectories. + +The intended result is generally not one universally optimal plan. It is a +cost--resilience frontier, together with the decisions that are optimal for +declared risk preferences and those that remain robust when far-tail event +probabilities are deeply uncertain. + +This responds to two connected questions: + +1. How should uncertainty be treated when studying very rare events, and what + long-range decisions are optimal under a spectrum of major heat-wave and + other black-sky risks? +2. How should confidence, uncertainty, and technology selection be treated + for sequential and compound stressors, such as a tropical storm occurring + during a heat wave under long-term load growth? + +## Event classes + +The framework should support a range of black-sky events rather than focus on +one hazard. + +### Extreme heat waves + +Heat waves are broad, evolving events that may simultaneously: + +- increase active and reactive demand; +- derate thermal generation and transmission capacity; +- alter solar and battery performance; +- impose water or fuel constraints; +- increase correlated equipment failures; and +- trigger wildfire-related outages or public-safety restrictions. + +Important uncertainties include geographic extent, temperature trajectory, +duration, nighttime relief, load response, equipment derating, correlated +failures, and forecast accuracy. Infrastructure may remain intact while the +system operates near physical limits for days or weeks. + +### Destructive storms and long restoration + +A destructive event may produce geographically concentrated asset loss and a +recovery lasting months or years. One illustrative trajectory is: + +- 80% of solar capacity becomes unavailable at an affected node; +- half of the lost capacity is restored within three months; and +- the remaining capacity returns over the following fifteen months. + +The uncertain quantities include storm path, local intensity, asset exposure, +damage fraction, correlated damage to nearby assets, accessibility, repair +resources, replacement-part availability, and restoration time. + +### Compound events + +The most consequential studies may combine hazards, such as an extreme heat +wave occurring while the network is still recovering from storm damage. The +framework should therefore represent persistent damage states as well as +shorter operational stress. + +A representative sequence could contain: + +1. a long-term load-growth trajectory that establishes the background demand; +2. a summer heat wave that raises load and derates generation, transmission, + and storage; +3. a tropical storm whose path damages geographically exposed resources and + network elements; +4. a constrained restoration period with limited crews, access, spares, fuel, + and replacement equipment; and +5. persistent or recurrent high temperatures while the system remains only + partially restored. + +The hazards and impacts must not be sampled as independent marginals when +seasonality, geography, or physical mechanisms correlate them. A compound +event model needs a joint or conditional scenario construction. + +## Long horizons as the technical enabler + +Long-horizon planning is not merely a larger OPF calculation. It is the +technical capability that lets sequential and compound events be represented +as one connected physical history. + +Independent event studies tend to begin each event from an artificially clean +state. They reset storage, restore damaged assets, replenish fuel and repair +inventories, make crews newly available, and remove the effects of preceding +operational decisions. Those resets can erase the mechanism that makes a +compound event consequential. + +A long-horizon model instead preserves state across the sequence: + +- battery state of charge and other stored-energy states; +- damaged, derated, repaired, and partially restored assets; +- fuel, spare-equipment, and material inventories; +- crew availability and repair progress; +- supply-chain delays; +- deferred maintenance or interrupted service; and +- the system's realized operating state entering the next stressor. + +The scientific chain is therefore: + +```text +event 1 + -> damage and operating response + -> partial recovery and resource consumption + -> event 2 + -> compound consequence +``` + +The horizon also enables anticipatory decisions. If a heat wave is forecast +after a storm, the policy may preserve battery energy, change repair +priorities, procure temporary generation, or accept a smaller present cost to +avoid a more consequential future outage. Separate event studies cannot +discover these tradeoffs. + +The central architectural proposition is: + +> Long-horizon optimization enables compound-event resilience studies by +> preserving physical, operational, and recovery state across events. + +## Structure of the uncertainty + +A common causal representation is: + +```text +hazard realization + | + v +geographic exposure + | + v +asset damage or derating + | + v +time-varying availability and recovery +``` + +The uncertainty model should distinguish: + +1. **Event occurrence:** the frequency of an event class. +2. **Spatial realization:** path, footprint, intensity field, and affected + nodes or corridors. +3. **Conditional impact:** capacity loss or derating, demand response, and + correlated failures given exposure. +4. **Duration and recovery:** hazard persistence, partial restoration, + repair time, and supply-chain constraints. +5. **Information arrival:** what is forecast before the event, observed + immediately afterward, or learned progressively during recovery. + +Spatial and temporal correlations are essential. Independent asset outages +would not adequately represent a storm path, regional heat wave, or shared +repair bottleneck. + +## Scientific treatment of very rare events + +For a nominal "1-in-1,000" event, the occurrence probability may be the +least defensible model input. The analysis should not imply that a far-tail +return period is known precisely. + +Report two complementary views: + +1. **Conditional resilience:** given that an event of a specified class + occurs, evaluate performance across plausible paths, severities, damage + realizations, and recovery trajectories. +2. **Probability-weighted tail risk:** where a defensible hazard distribution + exists, combine probability and consequence using expected loss, + exceedance probabilities, CVaR, or related measures. + +For poorly characterized hazards, stress testing, sensitivity analysis, +robust optimization, distributionally robust optimization, and minimax regret +are more defensible than assigning a precise probability. Severe events +outside the historical record can be explored as black-sky scenarios without +claiming that their occurrence rates are accurately calibrated. A genuinely +unforeseen black swan does not have a trustworthy prespecified distribution. + +## Confidence bounds and uncertainty reporting + +"Confidence bounds" can refer to different uncertainties that should not be +combined into one interval. + +### Outcome variability + +The event ensemble produces a distribution of physical and economic outcomes +across paths, intensities, damage levels, load-growth assumptions, and +recovery trajectories. Report medians, quantiles, exceedance probabilities, +conditional tail expectations, and worst credible outcomes. + +### Sampling uncertainty + +Only a finite number of scenarios can be evaluated. Repeated sampling, +bootstrap intervals, convergence diagnostics, and effective sample size can +quantify uncertainty in estimated means, quantiles, exceedance rates, and +CVaR. Rare-tail estimation may require stratified or importance sampling +rather than ordinary Monte Carlo sampling. + +### Model and epistemic uncertainty + +Hazard distributions, fragility curves, load-growth trajectories, recovery +models, and correlation assumptions may themselves be uncertain. A narrow +statistical confidence interval does not capture this. Compare alternative +model families, perturb important assumptions, or use an ambiguity set in a +distributionally robust formulation. Report whether technology rankings and +decisions remain stable across those alternatives. + +### Numerical and optimization uncertainty + +Solver status, residual audits, local-solution sensitivity, and relaxation or +rounding gaps are distinct from event uncertainty. They should be retained and +reported separately so that optimization artifacts are not mistaken for +physical tail variability. + +The report should therefore distinguish scenario spread, finite-sample +uncertainty, model sensitivity, and numerical solution quality rather than +calling all four "confidence." + +## Decision hierarchy + +The optimization must separate decisions by when they are made and what +information is available. + +### Pre-event decisions + +- storage siting, power rating, and energy capacity; +- geographic diversification of generation; +- firm capacity and reserve requirements; +- transmission reinforcement and infrastructure hardening; +- elevated-temperature equipment ratings; +- spare-equipment, fuel, and supply-chain contracts; +- demand-response capability; and +- customer-priority and load-shedding policies. + +### Adaptive operating decisions + +- generation dispatch and renewable curtailment; +- storage charging, discharging, and reserve management; +- demand response and prioritized load service; +- network topology and transfer decisions; and +- revised energy targets as forecasts and system state evolve. + +### Recovery decisions + +- repair prioritization and crew allocation; +- temporary generation and network configurations; +- replacement procurement; +- staged resource restoration; and +- operating policies during partial recovery. + +### Adaptive investments + +Some investments can be deferred until hazard trends, realized damage, or +recovery rates become observable. The long-range result may therefore be an +adaptive pathway with decision triggers rather than one irreversible plan +selected at the beginning of the study. + +## Selecting technology combinations + +The technology question is naturally a portfolio problem. Candidate resources +may include: + +- short- and long-duration storage; +- geographically diversified renewable generation; +- firm or dispatchable generation; +- transmission reinforcement and alternate delivery paths; +- microgrids and distributed resources serving critical loads; +- demand response and customer-priority programs; +- hardened assets and elevated-temperature equipment ratings; +- mobile generation and spare transformers; +- fuel, replacement-component, and repair-service contracts; and +- repair crews, inventories, and other restoration resources. + +The initial study can compare a frozen set of candidate portfolios. A later +planning layer can optimize continuous capacities and discrete siting, +construction, hardening, and contracting choices. + +Technology selection should not be based only on expected outage cost. The +analysis can instead produce a Pareto frontier or minimize cost subject to +explicit limits on quantities such as: + +- expected and tail energy not served; +- critical-load interruption; +- outage depth and duration; +- geographic or customer-class disparity; +- restoration time; and +- performance across an ambiguity set of compound-event models. + +The useful answer is not only which portfolio has the lowest expected cost. +It is which combinations prevent severe outcomes, protect critical services, +recover effectively, and retain their advantage when hazard, damage, +correlation, recovery, and load-growth assumptions change. + +## Optimization formulations + +A generic risk-aware planning problem has the form + +\[ +\min_{x,\pi} +\left[ +C_{\mathrm{investment}}(x) ++ \mathbb{E}_{\xi} C_{\mathrm{operation}}(x,\pi,\xi) ++ \lambda\,R(x,\pi,\xi) +\right], +\] + +where: + +- \(x\) contains long-range pre-event decisions; +- \(\pi\) is an adaptive operating and investment policy; +- \(\xi\) describes the event and information realization; and +- \(R\) is a tail-risk measure determined by the scientific question. + +Candidate treatments, in increasing order of commitment, include: + +1. **Scenario analysis:** evaluate a common plan over a frozen spectrum of + events. +2. **Stochastic optimization:** optimize expected performance with + scenario-dependent recourse. +3. **Risk-aware optimization:** include CVaR, exceedance limits, or explicit + resilience constraints. +4. **Robust or distributionally robust optimization:** protect performance + over an uncertainty set, including uncertainty in event probabilities. +5. **Adaptive planning:** optimize staged decisions tied to observable + thresholds or updated information. + +No risk measure is neutral. Expected cost, conditional tail loss, worst-case +loss, regret, and threshold reliability encode different preferences and +should be reported explicitly rather than collapsed into an unexplained +single objective. + +## Role of the hierarchical architecture + +The CVXOPF hierarchy makes large scenario studies plausible: + +- single-node or network-DC formulations can screen many years, portfolios, + and hazard realizations; +- detailed AC solves can focus on consequential event intervals, damaged + regions, and restoration transitions; and +- shared physical states, especially storage state of charge, can coordinate + the fidelity layers. + +It is unnecessary to run every ordinary interval at full AC fidelity. The +expensive model should be concentrated where network physics may change the +resilience conclusion. + +For compound events, the coarse long-horizon trajectory must remain the +authoritative carrier of state between high-fidelity intervals. Detailed AC +subproblems should inherit the correct damage state, resource availability, +and energy state rather than being initialized as independent events. + +## Batched convex optimization for uncertainty ensembles + +The recent open-source release of +[Moreau](https://github.com/moreau-project/moreau) introduces a potentially +important computational path. Moreau is a GPU-native conic solver designed +for parameterized, batched, and differentiable convex optimization, with a CPU +backend as well. It was designed by core CVXPY developers around CVXPY's +canonicalization, parameterization, and execution model rather than added as +an unrelated GPU solver interface. + +The principal opportunity is not necessarily to accelerate one optimization +problem. It is to solve large batches of structurally identical convex +problems while reusing the common model structure and limiting repeated +canonicalization and host--device transfer. + +### Natural batch dimensions + +Rare-event and compound-event studies generate candidate batches across: + +- hazard paths and geographic footprints; +- event intensity and duration; +- conditional damage fractions; +- recovery trajectories; +- load-growth assumptions; +- alternative fragility and recovery models; +- bootstrap or importance-sampling realizations; +- risk-aversion and penalty weights; +- compatible technology portfolios represented through parameters; and +- combinations of these dimensions. + +A representative workload has the form + +\[ +\text{portfolio} +\times \text{event path} +\times \text{damage realization} +\times \text{recovery model} +\times \text{statistical replicate}. +\] + +These are often not unrelated problems. Within an event family they may have +the same variables, constraint structure, and objective form, differing only +in parameter values. + +### Scientific value + +Greater convex-solve throughput can improve the uncertainty study itself by +allowing us to: + +- sample conditional tails more densely; +- reduce finite-sample uncertainty in estimated metrics; +- retain more geographically detailed paths and damage fields; +- evaluate more sequential and compound-event realizations; +- preserve alternative fragility and recovery models; +- perform targeted or importance sampling in consequential tail regions; +- test technology-portfolio ranking stability; and +- estimate exceedance probabilities and CVaR more reliably. + +This distinction is important: + +> Additional computation can reduce sampling uncertainty; it does not remove +> uncertainty in the hazard, fragility, damage, load-growth, or recovery +> model. + +Model uncertainty still requires sensitivity analysis, competing model +families, ambiguity sets, or distributionally robust formulations. + +### Placement in the hierarchy + +Moreau would apply only to compatible convex layers: + +- single-node economic dispatch; +- lossy-DC network planning; +- a future SOCP network formulation; +- convex technology-sizing models; and +- convex relaxations used before rounding and polishing. + +It would not replace IPOPT for nonlinear AC realization. The intended flow is: + +```text +batched event and portfolio parameters + | + v +GPU-batched convex outer solves +(single-node / lossy DC / future SOCP) + | + v +tail screening and consequential-case selection + | + v +parallel detailed AC realization and audit +``` + +This reinforces the multiscale strategy: use large batches of lower-cost +convex models to explore the uncertainty space, then concentrate nonlinear AC +work on the event intervals and portfolios capable of changing the scientific +conclusion. + +### Structural requirements and limits + +A solver batch requires a common canonical structure. Scenario variation +should be expressed through typed parameters where scientifically valid, +including: + +- load and renewable availability; +- generator and storage derating; +- branch capacity; +- damage and recovery multipliers; and +- cost, penalty, or risk weights. + +Topology changes, different device fleets, incompatible horizon lengths, or +different constraint families may require separate compilations and batches. +Cases should therefore be grouped by a declared structural signature. We +should not alter physical semantics merely to force unlike scenarios into one +batch. + +CVXPY disciplined parameterized programming compliance, parameter-update +cost, canonicalization reuse, GPU memory, and host--device transfer must be +measured rather than assumed. End-to-end throughput is the relevant metric, +not solver-kernel time alone. + +### Differentiability + +Moreau's differentiable interface may eventually provide sensitivities of +optimized outcomes to storage capacity, transmission ratings, resource +availability, recovery time, load growth, technology cost, or risk-policy +parameters. These derivatives could guide continuous technology sizing, +identify consequential uncertain inputs, and support adaptive scenario +selection. + +Sensitivity interpretation will require care near active-set transitions, +nonsmooth costs, and tail-risk statistics. Differentiability is therefore a +research opportunity, not a prerequisite for the first batching pilot. + +### Adoption gate + +No immediate production dependency is proposed. A controlled evaluation +should: + +1. instrument current construction, canonicalization, solve, transfer, and + extraction time; +2. identify DPP-compliant event parameters and graph-breaking dimensions; +3. establish CPU/Clarabel reference solutions and independent residual audits; +4. compare Moreau CPU and GPU objective, variable, and residual parity; +5. benchmark batch size, horizon, network size, memory use, GPU utilization, + and end-to-end throughput; and +6. test one representative uncertainty ensemble before deciding whether to + retain Moreau as an optional acceleration backend. + +## Outputs and evaluation metrics + +Candidate portfolios should be compared using both cost and physical outcome +metrics, including: + +- energy not served by geography and customer class; +- depth and duration of service loss; +- violations of critical-service thresholds; +- storage exhaustion, throughput, and replenishment time; +- renewable curtailment and stranded generation; +- voltage-support and congestion exposure; +- restoration time and repair-resource requirements; +- expected consequence and conditional tail consequence; +- worst credible consequence; and +- regret relative to the best plan for each realized event. + +Each reported statistic should be accompanied, where applicable, by: + +- a finite-sample uncertainty interval; +- sensitivity across alternative hazard and recovery models; +- the number and weighting of contributing scenarios; and +- numerical acceptance and optimization-quality diagnostics. + +The final result should identify: + +- investments justified across nearly all modeled tail assumptions; +- investments justified only beyond a stated severity or risk tolerance; +- plans that depend strongly on a particular path or recovery assumption; +- dominated portfolios; and +- the value of retaining adaptive options. + +## Practical research sequence + +1. Define one controlled heat-wave family and one destructive-storm family. +2. Define at least one sequential compound event, such as load growth plus a + heat wave, tropical-storm damage, partial recovery, and recurrent heat. +3. Specify which physical, operational, inventory, and recovery states persist + throughout the complete horizon. +4. Generate spatially and temporally correlated footprints, impacts, and + recovery paths. +5. Freeze a small candidate set of technology portfolios and adaptive + operating policies. +6. Evaluate those candidates across the event spectrum using coarse models. +7. Select consequential intervals, transitions, and realizations for detailed + AC realization without resetting their inherited state. +8. Quantify outcome distributions, finite-sample uncertainty, model + sensitivity, numerical quality, and portfolio regret separately. +9. Compare expected, conditional-tail, robust, and regret-based rankings. +10. Determine which uncertainty dimensions materially change the preferred + decisions. +11. Instrument structurally repeated convex workloads and evaluate an + optional Moreau CPU/GPU batching pilot with numerical-parity gates. +12. Use batching, if validated, to increase ensemble size and reduce + finite-sample uncertainty without narrowing the represented model + uncertainty. +13. Add continuous sizing decisions where convex formulations permit them. +14. Add discrete siting, construction, hardening, or contracting decisions + through an appropriate outer method, potentially relax--round--polish or a + mixed-integer planning model. +15. Re-evaluate selected portfolios with fixed-decision AC polishing. + +## Current capability and required extension + +CVXOPF can already evaluate operating policies and prescribed candidate +portfolios across long scenarios, with detailed AC realization of selected +periods. Fully optimizing investment selection requires an additional +planning layer for siting, sizing, construction, contracting, and other +discrete or long-lived decisions. + +Accordingly, the near-term question is candidate-portfolio evaluation and +robust ranking. The longer-term question is end-to-end optimization of the +portfolio and its adaptive policy. + +## Intended answer to the motivating question + +The framework should ultimately answer: + +> Which long-range investments and adaptive policies are optimal for an +> explicitly stated risk posture, and which remain valuable when the +> probabilities, footprints, damage levels, and recovery trajectories of +> major heat waves and other black-sky events are deeply uncertain? + +and: + +> Which technology combinations minimize outages and outage impacts when +> sequential and compound stressors act on a system that may still be damaged, +> resource-constrained, or incompletely recovered from preceding events, and +> how confident are we that those conclusions persist across sampling, model, +> and numerical uncertainty? + +The most defensible answer will be a cost--resilience frontier and a set of +robust decisions, not a single plan presented as universally optimal under a +fragile far-tail probability estimate. From b1b0aadbb3b36d24bac73e5d355f9834f1c59956 Mon Sep 17 00:00:00 2001 From: Bennet Meyers Date: Wed, 26 Aug 2026 15:36:59 -0700 Subject: [PATCH 11/28] docs: expand project update and reconcile solver comparison --- experiments/dnlp_vs_pypower/REPORT.tex | 7 +- experiments/dnlp_vs_pypower/demo.py | 15 +- .../cvxopf_project_update.tex | 379 ++++++++++++++---- .../weekly_update_20260826/make_figures.py | 73 +++- 4 files changed, 398 insertions(+), 76 deletions(-) diff --git a/experiments/dnlp_vs_pypower/REPORT.tex b/experiments/dnlp_vs_pypower/REPORT.tex index 8e30e7d..c701ec4 100644 --- a/experiments/dnlp_vs_pypower/REPORT.tex +++ b/experiments/dnlp_vs_pypower/REPORT.tex @@ -124,9 +124,10 @@ \subsection{Model agreement between languages} incidental modelling differences so that only the solution method differs: \begin{itemize} - \item \textbf{Branch flow limits are removed} on both sides (set to a very - large value). cvxopf does not yet enforce branch limits, so we relax - Pypower's as well. + \item \textbf{Branch flow limits are removed} on both sides. cvxopf selects + \texttt{enforce\_branch\_limits=False} explicitly, while Pypower's limits + are set to a very large value. This isolates the solution method from the + branch-limit representation. \item \textbf{DC-line reactive power is pinned to zero} on both sides (the DC links are modelled at unity power factor), and their terminal buses are treated identically. diff --git a/experiments/dnlp_vs_pypower/demo.py b/experiments/dnlp_vs_pypower/demo.py index 529a958..7d43c7d 100644 --- a/experiments/dnlp_vs_pypower/demo.py +++ b/experiments/dnlp_vs_pypower/demo.py @@ -33,7 +33,7 @@ import numpy as np from cvxopf.hvdc import hvdc_from_dcline -from cvxopf.problem import build_opf +from cvxopf.problem import OPFOptions, build_opf from cvxopf.results import extract_results from cvxopf.testcases.case9 import case9 from cvxopf.testcases.case9_dcline import case9_dcline @@ -71,11 +71,20 @@ def _build(smooth: bool, dc: bool): if smooth: case["gencost"] = SMOOTH_GENCOST.copy() links = hvdc_from_dcline(case["dcline"]) - build = build_opf(case, formulation="ac", hvdc=links) + build = build_opf( + case, + formulation="ac", + hvdc=links, + options=OPFOptions(enforce_branch_limits=False), + ) _graft_loss0(build, case) else: case = case9() if smooth else case9_pwl() - build = build_opf(case, formulation="ac") + build = build_opf( + case, + formulation="ac", + options=OPFOptions(enforce_branch_limits=False), + ) return build, links diff --git a/presentations/weekly_update_20260826/cvxopf_project_update.tex b/presentations/weekly_update_20260826/cvxopf_project_update.tex index 30de0d5..420c8b9 100644 --- a/presentations/weekly_update_20260826/cvxopf_project_update.tex +++ b/presentations/weekly_update_20260826/cvxopf_project_update.tex @@ -29,6 +29,7 @@ \title{CVXOPF: multiscale optimization for battery resilience} \subtitle{From nonlinear power flow to month-scale hierarchical control} \author{Bennet Meyers} +\institute{\url{https://github.com/cvxgrp/cvxopf}} \date{August 26, 2026} \begin{document} @@ -37,7 +38,7 @@ \titlepage \end{frame} -\begin{frame}{The research goal} +\begin{frame}{Research objectives} \textbf{How can we plan battery energy over long horizons while respecting the nonlinear AC network physics that determine whether each action is realizable?} \vspace{0.7em} @@ -61,7 +62,7 @@ \centering\large The project thesis: \textbf{plan energy globally; realize power flow locally.} \end{frame} -\begin{frame}{Why intertemporal optimization matters} +\begin{frame}{Intertemporal storage operation} \begin{columns}[c,onlytextwidth] \column{0.57\textwidth} \includegraphics[width=\textwidth,height=0.69\textheight,keepaspectratio]{../../experiments/battery_terminal/readme_intertemporal_storage.png} @@ -75,7 +76,46 @@ \end{columns} \end{frame} -\begin{frame}{Device physics are defined once and reused across fidelity levels} + +\begin{frame}[shrink=5]{Current modeling capabilities} + \small + \begin{columns}[T,onlytextwidth] + \column{0.48\textwidth} + \begin{block}{Network and formulations} + \begin{itemize}\tightitems + \item nonlinear AC OPF through CVXPY DNLP/IPOPT + \item convex lossy-DC and single-node formulations + \item active branch status and two-terminal AC thermal limits + \item sparse and dense network representations + \end{itemize} + \end{block} + \begin{block}{Intertemporal control} + \begin{itemize}\tightitems + \item single- and multistep problems + \item hard, shortfall, and soft terminal policies + \item public hierarchical DC--AC orchestration + \end{itemize} + \end{block} + \column{0.48\textwidth} + \begin{block}{First-class components} + \begin{itemize}\tightitems + \item dispatchable and nondispatchable generation + \item batteries with real/reactive capability and cycling cost + \item fixed and economically sheddable loads + \item lossy controllable HVDC links + \end{itemize} + \end{block} + \begin{block}{Research discipline} + \begin{itemize}\tightitems + \item typed identities and stable failure schemas + \item explicit objective time units + \item retained audit residuals and reproducible experiments + \end{itemize} + \end{block} + \end{columns} +\end{frame} + +\begin{frame}{Component models across network formulations} \centering \large A shared component model makes DC planning and AC realization parts of \textbf{one mathematical system}. @@ -104,45 +144,7 @@ \end{itemize} \end{frame} -\begin{frame}[shrink=5]{What the software can model today} - \small - \begin{columns}[T,onlytextwidth] - \column{0.48\textwidth} - \begin{block}{Network and formulations} - \begin{itemize}\tightitems - \item nonlinear AC OPF through CVXPY DNLP/IPOPT - \item convex lossy-DC and single-node formulations - \item active branch status and two-terminal AC thermal limits - \item sparse and dense network representations - \end{itemize} - \end{block} - \begin{block}{Intertemporal control} - \begin{itemize}\tightitems - \item single- and multistep problems - \item hard, shortfall, and soft terminal policies - \item public hierarchical DC--AC orchestration - \end{itemize} - \end{block} - \column{0.48\textwidth} - \begin{block}{First-class components} - \begin{itemize}\tightitems - \item dispatchable and nondispatchable generation - \item batteries with real/reactive capability and cycling cost - \item fixed and economically sheddable loads - \item lossy controllable HVDC links - \end{itemize} - \end{block} - \begin{block}{Research discipline} - \begin{itemize}\tightitems - \item typed identities and stable failure schemas - \item explicit objective time units - \item retained audit residuals and reproducible experiments - \end{itemize} - \end{block} - \end{columns} -\end{frame} - -\begin{frame}[shrink=3]{The same branch limit can have very different numerical behavior} +\begin{frame}[shrink=3]{Branch-limit formulations: direct and lifted} \begin{columns}[T,onlytextwidth] \column{0.47\textwidth} \centering @@ -171,17 +173,89 @@ lifting reduced solve time by 27$\times$ (sparse) and 110$\times$ (dense). \end{frame} -\begin{frame}{Terminal energy is an economic decision, not a boundary detail} +\begin{frame}{CVXOPF--Pypower comparison} \centering - \includegraphics[width=0.98\textwidth,height=0.68\textheight,keepaspectratio]{terminal_policy_results.pdf} + \textbf{Four matched variants of the 9-bus AC-OPF test case}\par + \small CVXOPF and Pypower solved each variant independently; + entries show CVXOPF / Pypower objective values. + \vspace{0.5em} + + \small + \begin{tabular}{lcc} + \toprule + & \textbf{No controllable DC links} & \textbf{Three controllable DC links} \\ + \midrule + Smooth quadratic costs + & 5296.69 / 5296.69 + & 5262.04 / 5314.28 \quad (1.0\%) \\ + Piecewise-linear costs + & 5322.94 / 5322.94 + & \textbf{5469.04 / 6249.87 \quad (14.3\%)} \\ + \bottomrule + \end{tabular} + \vspace{0.8em} + + \begin{itemize}\tightitems + \item The cases differed only in generator cost representation (smooth or PWL) and the presence of three controllable DC links. + \item The solvers agreed without DC links; with smooth costs and DC links, their objectives differed by only 1.0\%. + \item With both PWL costs and controllable DC links, Pypower returned 6249.87 even though CVXOPF found a matched-feasible point costing 5469.04: Pypower was \textbf{at least 14.3\% suboptimal}. + \end{itemize} +\end{frame} + +\begin{frame}{Cross-evaluation of solver solutions} + \begin{columns}[c,onlytextwidth] + \column{0.47\textwidth} + \centering + \textbf{The decisive comparison} + \vspace{0.5em} + + \[ + x_{\mathrm{CVXOPF}} \in \mathcal F_{\mathrm{Pypower}} + \] + \[ + \begin{aligned} + J(x_{\mathrm{CVXOPF}}) &= 5469.04,\\ + J(x_{\mathrm{Pypower}}) &= 6249.87, + \end{aligned} + \] + \[ + \Delta J = 780.83 + \] + \small Worst reconstructed constraint residual: + $2.7\times10^{-9}$. + + \column{0.49\textwidth} + \small + \begin{itemize}\tightitems + \item Cross-evaluated objective values agree. + \item The CVXOPF point satisfies Pypower's neutralized feasible set, including its fixed converter-loss law. + \item Pypower's returned point is therefore demonstrably suboptimal. + \item Accepted explanation: DNLP canonicalization replaces PWL kinks with a smooth epigraph problem, helping the local solver reach a better basin. + \item This does \textbf{not} establish global optimality; AC OPF remains nonconvex. + \end{itemize} + \end{columns} + \vspace{0.5em} + \centering\small Independent feasibility audits are stronger evidence than + agreement with a familiar solver. +\end{frame} + +\begin{frame}{Representative 96-hour scenarios} + \centering + \includegraphics[width=0.98\textwidth,height=0.78\textheight,keepaspectratio]{representative_scenarios.pdf} + \par\scriptsize Regime labels describe energy conditions across the full window; + the moderate case has the largest instantaneous net-load peak. +\end{frame} + +\begin{frame}{Battery terminal-energy policies} + \centering + \includegraphics[width=0.98\textwidth,height=0.65\textheight,keepaspectratio]{terminal_policy_results.pdf} \begin{itemize}\small\tightitems - \item The sampled fixed-terminal value is empirically convex and piecewise smooth. - \item Linear penalties recover a hard target beyond a marginal-value threshold; quadratic penalties create a smooth tradeoff. - \item Terminal policy therefore encodes the value or obligation attached to energy beyond the modeled horizon. + \item In each regime, the sampled fixed-terminal value is empirically convex and piecewise smooth. + \item Linear penalties recover a hard target beyond a marginal-value threshold; quadratic penalties create a smooth tradeoff, encoding the value attached to energy beyond the horizon. \end{itemize} \end{frame} -\begin{frame}{Long-horizon energy states can coordinate short-horizon AC solves} +\begin{frame}{DC signposts for rolling AC OPF} \centering \includegraphics[width=0.98\textwidth,height=0.68\textheight,keepaspectratio]{locality_and_handoff.pdf} \begin{itemize}\small\tightitems @@ -190,7 +264,7 @@ \end{itemize} \end{frame} -\begin{frame}{Two hierarchical paradigms share the same AC realization} +\begin{frame}{Frozen planning and closed-loop replanning} \begin{columns}[T,onlytextwidth] \column{0.48\textwidth} \centering @@ -233,7 +307,7 @@ \end{itemize} \end{frame} -\begin{frame}{The 96-hour study validated hierarchical control} +\begin{frame}{96-hour hierarchical study} \centering \includegraphics[width=0.96\textwidth,height=0.58\textheight,keepaspectratio]{m17_soc_trajectories.pdf} \begin{itemize}\tightitems @@ -242,7 +316,7 @@ \end{itemize} \end{frame} -\begin{frame}{Causal initialization recovery works in the reference scenario} +\begin{frame}{Causal warm-start recovery} \begin{columns}[T,onlytextwidth] \column{0.58\textwidth} \textbf{Frozen 96-hour recovery experiment} @@ -262,7 +336,7 @@ \end{columns} \end{frame} -\begin{frame}{Case118 makes the computational boundary visible} +\begin{frame}{Case118 computational scaling} \begin{columns}[T,onlytextwidth] \column{0.54\textwidth} \textbf{Six-hour rated AC pilot} @@ -281,7 +355,7 @@ \end{columns} \end{frame} -\begin{frame}{The hierarchy has progressed from hours to a month} +\begin{frame}{Scaling from 96 hours to one month} \small \begin{center} \begin{tikzpicture}[scale=0.80,transform shape,node distance=5mm, @@ -303,7 +377,7 @@ \end{itemize} \end{frame} -\begin{frame}{Process recycling controls memory without changing the science} +\begin{frame}{Process recycling and memory use} \centering \includegraphics[width=0.98\textwidth,height=0.69\textheight,keepaspectratio]{recycling_memory.pdf} \begin{itemize}\small\tightitems @@ -313,7 +387,7 @@ \end{itemize} \end{frame} -\begin{frame}{The annual study separates planning, partitioning, and execution} +\begin{frame}{Annual-study execution architecture} \centering \begin{tikzpicture}[scale=0.88,transform shape,node distance=7mm and 10mm, box/.style={draw=customblue,rounded corners,fill=customblue!7,minimum width=30mm,minimum height=13mm,align=center}, @@ -332,7 +406,7 @@ \end{itemize} \end{frame} -\begin{frame}{Annual failure identifies the next milestone} +\begin{frame}{Annual-study resource limit} \begin{columns}[T,onlytextwidth] \column{0.50\textwidth} \textbf{What the failed workers established} @@ -354,14 +428,15 @@ \end{columns} \end{frame} -\begin{frame}{What we have learned} +\begin{frame}{Key findings} + \small \begin{enumerate}\tightitems - \item \textbf{Model structure matters computationally.} Equivalent nonlinear formulations can differ by orders of magnitude in tractability. - \item \textbf{Terminal energy is part of the scientific model.} Hard obligations, reserve floors, and soft value functions answer different questions. - \item \textbf{DC signposts can coordinate AC realizations.} The layers need shared state, not identical trajectories. - \item \textbf{Feedback is not recursive feasibility.} Soft deviations can consume the remaining ability to satisfy a terminal obligation. - \item \textbf{Solver recovery is operationally relevant.} Causal warm starts distinguish numerical failure from demonstrated physical infeasibility. - \item \textbf{Scaling requires both algebra and systems engineering.} Time-vectorized graphs, supervision, immutable artifacts, recycling, and sharding are part of doing the science correctly. + \item \textbf{Formulation matters.} Equivalent branch constraints differed radically in solve time; CVXOPF also proved Pypower at least 14.3\% suboptimal in one matched case. + \item \textbf{Terminal energy is a policy choice.} Hard targets, reserve floors, and soft penalties answer different physical and economic questions. + \item \textbf{Hierarchical DC--AC control works.} Long-horizon DC signposts coordinated rolling AC network solves across 96 hours. + \item \textbf{Frozen and replanned control both worked.} Hard policies tracked the DC plan; soft policies traded exact tracking for flexibility as intended. This scenario did not require continuous replanning. + \item \textbf{Initialization is part of solve policy.} Causal warm starts and target-free recovery resolved failures that flat starts misclassified as infeasibility. + \item \textbf{Long horizons need multiple scaling tools.} Time vectorization, copper-plate outer models, and overlapping AC shards offer complementary paths to multi-year studies. \end{enumerate} \end{frame} @@ -389,23 +464,191 @@ \appendix -\begin{frame}{Appendix: load shedding is now a first-class reliability decision} +\begin{frame}{Appendix: AC network formulation} + \textbf{Full nonlinear network realization} + \begin{columns}[T,onlytextwidth] + \column{0.48\textwidth} + \textbf{Preserved physics} + \begin{itemize}\small\tightitems + \item voltage magnitude and phase angle at every bus + \item nonlinear active and reactive nodal balance + \item complex branch admittance, fixed transformer taps, and phase shifts + \item voltage bounds and a reference angle + \item apparent-power limits at both branch terminals + \end{itemize} + \column{0.48\textwidth} + \textbf{Computational role} + \begin{itemize}\small\tightitems + \item accepts active and reactive device contributions + \item reports terminal flows, voltages, and physical losses + \item nonconvex formulation canonicalized through CVXPY DNLP + \item solved locally with IPOPT; accepted results are not global certificates + \item used as the high-fidelity realization layer + \end{itemize} + \end{columns} +\end{frame} + +\begin{frame}{Appendix: lossy-DC network formulation} + \textbf{Convex network-aware planning model} + \begin{columns}[T,onlytextwidth] + \column{0.48\textwidth} + \textbf{Preserved structure} + \begin{itemize}\small\tightitems + \item signed active-power flow on every in-service branch + \item active-power conservation at every bus + \item branch flow limits and device location + \item convex generator and component costs + \item resistance-weighted quadratic flow penalty + \end{itemize} + \column{0.48\textwidth} + \textbf{Approximation and role} + \begin{itemize}\small\tightitems + \item omits voltage magnitude and reactive power + \item the quadratic ``loss'' term regularizes costly flow; nodal conservation itself remains lossless + \item convex QP solved with CLARABEL + \item retains congestion and spatial delivery constraints + \item used for long-horizon network planning and battery signposts + \end{itemize} + \end{columns} +\end{frame} + +\begin{frame}{Appendix: single-node network formulation} + \textbf{Copper-plate economic dispatch} + \begin{columns}[T,onlytextwidth] + \column{0.48\textwidth} + \textbf{Preserved structure} + \begin{itemize}\small\tightitems + \item one aggregate active-power balance per interval + \item generator, load, storage, and renewable device limits + \item storage dynamics and terminal policies + \item time-integrated device costs + \item device-level identities and reporting + \end{itemize} + \column{0.48\textwidth} + \textbf{Omissions and role} + \begin{itemize}\small\tightitems + \item no buses, branch flows, congestion, or transmission losses + \item no voltage or reactive power + \item HVDC links make an explicit null contribution after network collapse + \item convex QP solved with CLARABEL + \item cheapest outer model for very long horizons and aggregate energy signposts + \end{itemize} + \end{columns} +\end{frame} + +\begin{frame}{Appendix: dispatchable generators} + \textbf{\texttt{DispatchableGenerator}} represents a conventional generator at one bus. + \begin{columns}[T,onlytextwidth] + \column{0.48\textwidth} + \textbf{Configured data} + \begin{itemize}\small\tightitems + \item bus, status, and voltage setpoint + \item active-power minimum and maximum + \item reactive-power minimum and maximum + \item polynomial or piecewise-linear operating cost + \item startup and shutdown costs retained for data fidelity, but currently inactive + \end{itemize} + \column{0.48\textwidth} + \textbf{Model contribution} + \begin{itemize}\small\tightitems + \item active injection in every formulation + \item reactive injection and limits in AC + \item optional AC voltage-setpoint enforcement + \item time-integrated operating cost + \item MATPOWER generator and cost rows convert to the same object + \end{itemize} + \end{columns} +\end{frame} + +\begin{frame}{Appendix: nondispatchable generation} + \textbf{\texttt{NondispatchableUnit}} represents inverter-coupled wind, solar, or another availability-limited source. + \begin{columns}[T,onlytextwidth] + \column{0.48\textwidth} + \textbf{Configured data} + \begin{itemize}\small\tightitems + \item bus and stable device identity + \item available active power + \item apparent-power rating + \item optional device-aligned time series of availability + \end{itemize} + \column{0.48\textwidth} + \textbf{Model contribution} + \begin{itemize}\small\tightitems + \item dispatch between zero and available power + \item curtailment reported as availability minus dispatch + \item joint active/reactive inverter circle in AC + \item explicit active-power availability and rating bounds in DC + \item no reactive variable in DC formulations + \end{itemize} + \end{columns} +\end{frame} + +\begin{frame}{Appendix: ideal storage} + \textbf{\texttt{StorageUnitIdeal}} represents a lossless battery with intertemporal energy state. + \begin{columns}[T,onlytextwidth] + \column{0.48\textwidth} + \textbf{Configured data} + \begin{itemize}\small\tightitems + \item bus, stable identity, power rating, and energy capacity + \item initial state of charge + \item cycling-cost weight + \item optional hard or soft terminal policy, target, and weight + \end{itemize} + \column{0.48\textwidth} + \textbf{Model contribution} + \begin{itemize}\small\tightitems + \item positive real power denotes discharge + \item $q_t=q_{t-1}-\Delta b_t$ with $0\leq q_t\leq Q$ + \item active/reactive power circle in AC; symmetric active-power bound in DC + \item integrated one-way-throughput penalty + \item equality, reserve-floor, and linear or quadratic terminal policies + \end{itemize} + \end{columns} +\end{frame} + +\begin{frame}{Appendix: controllable HVDC links} + \textbf{\texttt{HVDCLink}} represents a controllable transfer through paired terminal injections. + \begin{columns}[T,onlytextwidth] + \column{0.48\textwidth} + \textbf{Configured data} + \begin{itemize}\small\tightitems + \item from/to buses and stable device identity + \item signed transfer minimum and maximum + \item proportional loss percentage + \item polynomial transfer cost + \item optional device-aligned time-varying bounds + \end{itemize} + \column{0.48\textwidth} + \textbf{Model contribution} + \begin{itemize}\small\tightitems + \item injections at both terminals enter nodal balance + \item direction-aware proportional-loss equality + \item forward-only, reverse-only, bidirectional, or pinned operation + \item symmetric cost on transfer magnitude + \item explicit null contribution in the single-node formulation + \end{itemize} + \end{columns} +\end{frame} + +\begin{frame}{Appendix: loads and load shedding} + \textbf{\texttt{Load}} represents an identified active/reactive demand channel with an optional shedding policy. \begin{itemize}\tightitems - \item Loads have stable identities, fixed active/reactive demand, optional shedding eligibility, fractional caps, and VOLL-like costs. + \item Configured data include bus, stable identity, signed active demand, optional reactive demand, shedding cost, and maximum shed fraction. + \item With no shedding cost, the load is fixed and introduces no decision variable; an explicit load fleet replaces the complete MATPOWER load fleet. \item The model reports served load, shed load, fraction shed, energy not served, and integrated shedding cost. \item In the controlled single-node case, shedding below the relevant generator marginal cost and full service above it produce the expected economic phase transition. - \item Explicit time-varying inequalities and leaf-bound representations agreed to solver precision; explicit inequalities were retained for clarity and uniformity. + \item AC models active and reactive service together; DC retains reactive demand as input metadata without optimizing reactive service. \end{itemize} \end{frame} -\begin{frame}{Appendix: scientific boundaries} +\begin{frame}{Appendix: scope and limitations} \small \begin{itemize}\tightitems \item AC results are accepted local solutions from CVXPY DNLP/IPOPT, not global-optimality certificates. \item Results establish behavior for the frozen case9/Tracy and synthetic Case118 scenarios; they are not universal reliability claims. \item The current lossy-DC formulation penalizes a resistance proxy but retains lossless nodal conservation; AC provides the physical-loss realization. \item The reactive-support tie-breaker is a planned experiment, not a completed result. - \item The historical DNLP/Pypower HVDC cross-evaluation needs reconciliation with the current post-branch-limit implementation before reuse as a headline result. + \item The CVXOPF/Pypower cross-evaluation intentionally neutralizes branch limits in both models; it does not characterize the current branch-constrained default. \end{itemize} \end{frame} diff --git a/presentations/weekly_update_20260826/make_figures.py b/presentations/weekly_update_20260826/make_figures.py index 1e79cd9..b9ef7ff 100644 --- a/presentations/weekly_update_20260826/make_figures.py +++ b/presentations/weekly_update_20260826/make_figures.py @@ -40,19 +40,87 @@ def finish(fig: plt.Figure, name: str) -> None: plt.close(fig) +def representative_scenarios() -> None: + inputs = pd.read_csv(BATTERY / "scenario_inputs.csv") + trajectories = pd.read_csv(BATTERY / "policy_trajectories.csv") + regimes = ("low", "moderate", "high") + regime_labels = { + "low": "Low net energy", + "moderate": "Medium net energy", + "high": "High net energy", + } + fig, axes = plt.subplots(3, 2, figsize=(10.8, 6.2), sharex=True) + for row, scenario in enumerate(regimes): + scenario_inputs = inputs[inputs["scenario"] == scenario].sort_values("step") + hard = trajectories[ + (trajectories["scenario"] == scenario) + & (trajectories["policy"] == "equality") + ].sort_values("step") + if len(scenario_inputs) != 96 or len(hard) != 96: + raise ValueError(f"Expected 96 inputs and hard-target states for {scenario}") + + power_ax, soc_ax = axes[row] + power_ax.step( + scenario_inputs["step"], + scenario_inputs["load_mw"], + where="post", + color=BLUE, + linewidth=1.2, + label="Load", + ) + power_ax.step( + scenario_inputs["step"], + scenario_inputs["renewable_available_mw"], + where="post", + color=ORANGE, + linewidth=1.2, + label="Renewable availability", + ) + soc_steps = np.arange(97) + soc = np.r_[hard["initial_soc_mwh"].iloc[0], hard["soc_mwh"].to_numpy()] + soc_ax.plot(soc_steps, soc, color=BLUE, linewidth=1.5, label="Optimized SoC") + soc_ax.axhline( + 500, color=ORANGE, linestyle="--", linewidth=1.0, label="500 MWh target" + ) + power_ax.set_ylabel(f"{regime_labels[scenario]}\nPower (MW)") + soc_ax.set_ylabel("SoC (MWh)") + power_ax.grid(alpha=0.2) + soc_ax.grid(alpha=0.2) + soc_ax.set_ylim(-30, 1030) + + axes[0, 0].set_title("Exogenous power trajectories", fontweight="bold") + axes[0, 1].set_title("Hard-target battery realization", fontweight="bold") + axes[-1, 0].set_xlabel("Hour") + axes[-1, 1].set_xlabel("Hour") + axes[0, 0].legend(frameon=False, ncols=2, fontsize=8, loc="upper right") + axes[0, 1].legend(frameon=False, ncols=2, fontsize=8, loc="upper right") + finish(fig, "representative_scenarios.pdf") + + def terminal_value() -> None: data = pd.read_csv(BATTERY / "terminal_value_sweep.csv") fig, axes = plt.subplots(1, 2, figsize=(10.8, 4.0)) + regime_labels = { + "low": "Low: renewable surplus", + "moderate": "Moderate: energy-balanced, peak deficit", + "high": "High: sustained energy deficit", + } for scenario, group in data.groupby("scenario", sort=False): group = group[group["status"].isin(("optimal", "optimal_inaccurate"))] operating = group["objective"] - group["objective"].min() - axes[0].plot(group["target_mwh"], operating, marker="o", ms=3, label=scenario) + axes[0].plot( + group["target_mwh"], + operating, + marker="o", + ms=3, + label=regime_labels[scenario], + ) axes[0].set( xlabel="Required terminal SoC (MWh)", ylabel="Incremental operating cost" ) axes[0].set_title("Terminal energy has a convex operating value", fontweight="bold") axes[0].grid(alpha=0.25) - axes[0].legend(frameon=False) + axes[0].legend(frameon=False, fontsize=8) soft = pd.read_csv(BATTERY / "soft_weight_sweep.csv") high = soft[soft["scenario"] == "high"] @@ -304,6 +372,7 @@ def main() -> None: plt.rcParams.update( {"font.size": 10, "axes.spines.top": False, "axes.spines.right": False} ) + representative_scenarios() terminal_value() locality_and_handoff() formulation_results() From 938038f4002e22fe61867c8b8b78c987cdacd767 Mon Sep 17 00:00:00 2001 From: Bennet Meyers Date: Wed, 26 Aug 2026 15:44:08 -0700 Subject: [PATCH 12/28] docs: explain primitive-based economic dispatch --- README.md | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/README.md b/README.md index 887c0df..2761811 100644 --- a/README.md +++ b/README.md @@ -123,6 +123,33 @@ affine extension of the load feasible set with a high linear value-of-lost-load cost in the original optimization problem; it is not a lexicographic pass, an anonymous balance slack, or a second feasibility-restoration solve. +#### Economic decisions from modeled primitives + +CVXOPF constructs economic dispatch from explicit physical and economic +primitives: + +- generator cost curves; +- load and renewable availability; +- network limits and either physical AC losses or a documented DC loss proxy; +- storage dynamics, cycling cost, and terminal policy (with ideal efficiency + in the current `StorageUnitIdeal` model); +- load-shedding cost; and +- the evolving intertemporal system state. + +Exogenous electricity-price trajectories are not first-class inputs to the +current model. Dispatch costs and scarcity consequences are represented +directly, while marginal values arise endogenously from the optimization. This +distinction is especially important in black-sky studies: a historical price +series reflects a different network state, asset fleet, market design, and +damage condition. Using that scalar signal to stand in for widespread outages, +physical scarcity, customer consequences, and months of recovery would ask it +to reconstruct interactions that the model had omitted. + +This does not imply that tariffs, contracts, or other explicit economic rules +can never be modeled. When they are part of the scientific question, they +should enter transparently as defined costs or constraints rather than serve +as substitutes for available physical structure. + AC voltage magnitudes and reactive dispatch are currently governed by their physical bounds and network equations but are generally not assigned an operating preference in the objective. Reactive variables can therefore reach From f0dd57055e284a4c16e21ca3f01895c1fe2afce8 Mon Sep 17 00:00:00 2001 From: Bennet Meyers Date: Wed, 26 Aug 2026 16:21:23 -0700 Subject: [PATCH 13/28] docs: frame coordination from modeled primitives --- ...AL_COORDINATION_FROM_MODELED_PRIMITIVES.md | 197 ++++++++++++++++++ 1 file changed, 197 insertions(+) create mode 100644 experiments/ecosystem_positioning/PHYSICAL_COORDINATION_FROM_MODELED_PRIMITIVES.md diff --git a/experiments/ecosystem_positioning/PHYSICAL_COORDINATION_FROM_MODELED_PRIMITIVES.md b/experiments/ecosystem_positioning/PHYSICAL_COORDINATION_FROM_MODELED_PRIMITIVES.md new file mode 100644 index 0000000..3982761 --- /dev/null +++ b/experiments/ecosystem_positioning/PHYSICAL_COORDINATION_FROM_MODELED_PRIMITIVES.md @@ -0,0 +1,197 @@ +# Physical coordination from modeled primitives + +## Purpose + +This note states a research proposition motivating CVXOPF: + +> A complex, intertemporal energy system can be coordinated directly from its +> physical capabilities, explicit operating costs, reliability priorities, and +> evolving state. + +This is a constructive and testable proposition. It begins with the causal +structure of the energy system rather than treating any particular +coordination mechanism as the conceptual baseline. Prices, contracts, +decentralized decisions, and other institutional arrangements may still be +represented when they are relevant to the scientific question. + +## Model the causal structure directly + +CVXOPF builds dispatch decisions from explicit physical and economic +primitives, including: + +- generator operating regions and cost curves; +- load and renewable availability; +- network topology, operating limits, and either physical losses or documented + loss proxies; +- storage power, energy state, cycling cost, and terminal policy; +- load-shedding eligibility, limits, and consequences; and +- the realized state inherited from earlier decisions and events. + +These quantities determine what the system can do and what consequences follow +from its decisions. When they are available, representing them directly is +more scientifically informative than asking an external scalar signal to +stand in for their combined effect. + +## Prices and marginal values have a narrower role + +The distinction is not between using economics and ignoring economics. +Generator costs, interruption consequences, storage opportunity value, and +terminal obligations are economic parts of the modeled problem. + +The distinction concerns the role assigned to prices: + +- An **exogenous price forecast** is supplied to the model and used to drive + decisions. +- An **endogenous marginal value** follows from a specified optimization + problem and describes the local value of relaxing one of its constraints. + +Endogenous marginal values can be useful diagnostics, accounting quantities, +or inputs to an implemented coordination mechanism. They remain conditional +on the modeled network, device fleet, objective, constraints, state, and +operating rules. They do not replace those structures. + +## Mathematical formulation and temporal incentives + +The widespread use of price-driven asset models is partly encouraged by +tractable linear formulations. If a storage device is separated from the +physical system and assigned an objective such as + +$$\min_b \sum_t \pi_t b_t,$$ + +the supplied price trajectory carries nearly all information about when +charging and discharging should be valuable. By contrast, a system model can +co-optimize production and storage from generator costs, balance, network +constraints, and storage dynamics: + +$$\min_{p,b} \sum_t C(p_t).$$ + +When production cost is strongly convex, redistributing generation across time +can reduce modeled cost directly. Storage can therefore levelize dispatch in +response to load, renewable availability, congestion, and system state without +requiring an externally supplied temporal value signal. + +Linear programming does not inherently require exogenous prices. System-wide +linear programs can co-optimize devices and networks, piecewise-linear costs +can produce changing marginal values, and scarcity or congestion can create +temporal and spatial differentiation. The narrower concern is the combination +of linearized production costs, decomposed price-taking asset models, omitted +physical interactions, and the treatment of a resulting price series as a +sufficient statistic for the omitted system. + +## Why the distinction matters for rare events + +A historical electricity-price trajectory was produced under a particular +network state, asset fleet, market design, demand pattern, and set of operating +rules. A destructive event may change all of them at once. For example, it may +remove a geographically concentrated fraction of generation, damage +transmission, raise demand, constrain fuel or replacement supply, and create a +recovery process lasting months. + +Under those conditions, a historical price signal is not merely uncertain. It +may describe a materially different system. Asking it to represent physical +scarcity, customer consequences, sequential damage, and recovery implicitly +asks the signal to reconstruct interactions omitted from the model. + +A physical-state model instead updates the affected capabilities and solves +the resulting coordination problem. Uncertainty can be represented through +event ensembles, uncertain damage and recovery trajectories, alternative +technology portfolios, and repeated adaptive solves. + +## Long horizons and evolving state + +Energy coordination is not a sequence of independent interval decisions. +Storage depletion, repair, fuel availability, cumulative customer impact, and +other state variables connect earlier actions to later feasibility. + +Long-horizon models make these connections explicit. They allow the study to +ask whether a policy: + +- preserves energy for later scarcity; +- remains viable across sequential or compound events; +- adapts to realized damage and recovery; +- shifts consequences among locations or customer groups; and +- produces acceptable outcomes over the complete event rather than only the + next dispatch interval. + +## Hierarchical coordination + +No single formulation must resolve every physical detail over the entire +horizon. CVXOPF's hierarchical method separates complementary tasks: + +1. A long-horizon convex model coordinates the intertemporal states that must + remain globally coherent. +2. A shorter-horizon nonlinear AC model realizes decisions within detailed + active-power, reactive-power, voltage, and network constraints. +3. Realized state is returned to the planning layer for subsequent decisions. + +The layers should exchange only the information required for cross-scale +coordination. Over-specifying the detailed trajectory can convert harmless +approximation differences into artificial infeasibility. Preserving local +degrees of freedom allows the higher-fidelity layer to absorb variation while +respecting the essential state handoff. + +The resulting engineering principle is: + +> Coordinate invariants; do not micromanage trajectories. + +In the current battery hierarchy, state-of-charge signposts provide temporal +coherence while the AC layer remains free to redispatch generation, +nondispatchable output, storage power, reactive support, and voltage state. + +## What would constitute evidence + +The proposition should be evaluated through controlled studies, not asserted +from the formulation alone. Relevant evidence includes: + +- completion of long and compound event trajectories; +- independently audited physical feasibility; +- energy-not-served and other consequence metrics; +- preservation or recovery of critical state variables; +- performance across uncertain damage and recovery ensembles; +- comparisons among technology portfolios and control policies; +- sensitivity to modeling assumptions and objective choices; and +- computational cost, failure modes, and recovery behavior. + +Comparisons with price-driven controllers may also be informative, provided +the price inputs, information available to each controller, and acceptance +criteria are specified consistently. + +## Boundaries of the claim + +Successful coordination would establish the performance of the modeled +physical, economic, and control architecture. One implication would be that an +externally forecast market-clearing price is not mathematically necessary for +that operating problem. The result would not by itself establish that: + +- the chosen objective captures every social priority; +- the input costs are uniquely correct; +- one organizational arrangement should govern the system; +- centralized information is complete or costless; +- every relevant behavior has been modeled; or +- the resulting plan is globally optimal when nonlinear AC optimization is + used. + +Those are separate scientific, institutional, and normative questions. One +advantage of the explicit modeling approach is that the assumed objectives, +constraints, priorities, and omissions remain visible and open to revision. + +## Research direction + +CVXOPF provides a platform for testing whether primitive-based, adaptive, and +physically audited coordination can manage increasingly demanding energy +resilience problems. The next research dimensions include: + +- uncertain and geographically resolved damage ensembles; +- sequential and compound events; +- long recovery trajectories; +- technology-portfolio selection under tail risk; +- additional consequence metrics and customer priorities; +- convex screening followed by selected nonlinear AC realization; and +- scalable execution through vectorization, batching, and temporal + decomposition. + +The central question remains empirical: + +> How effectively can explicit models of system capabilities, costs, +> consequences, and evolving state coordinate energy provisioning across +> ordinary operation, severe disruption, and recovery? From 457ec9200050eae2a60dd470a131155a0ddaa53f Mon Sep 17 00:00:00 2001 From: Bennet Meyers Date: Wed, 26 Aug 2026 16:55:21 -0700 Subject: [PATCH 14/28] fix(m14a): qualify reviewed execution provenance Allow a narrowly scoped review exception for non-execution worktree changes while preserving clean source and launch provenance. Keep ladder completeness independent from the exception, record dirty worker evidence, and add focused regressions for valid, invalid, and incomplete reviewed executions. --- .../M14A_EXECUTION_REVIEW.json | 14 ++ .../m14_time_vectorization/M14A_PROTOCOL.md | 17 ++- .../m14_time_vectorization/m14a_analysis.py | 132 ++++++++++++++++-- tests/test_m14a_analysis.py | 123 +++++++++++++++- 4 files changed, 260 insertions(+), 26 deletions(-) create mode 100644 experiments/m14_time_vectorization/M14A_EXECUTION_REVIEW.json diff --git a/experiments/m14_time_vectorization/M14A_EXECUTION_REVIEW.json b/experiments/m14_time_vectorization/M14A_EXECUTION_REVIEW.json new file mode 100644 index 0000000..c314706 --- /dev/null +++ b/experiments/m14_time_vectorization/M14A_EXECUTION_REVIEW.json @@ -0,0 +1,14 @@ +{ + "execution_commit": "1dd5e36dcae5ad9c8176b1d1202f1055acf95c03", + "execution_source_fingerprint": "02567a6928cede7d51d555affb84107e480a87adf748676f0e2ed2e598232e1b", + "paths": [ + "experiments/dnlp_vs_pypower/REPORT.tex", + "experiments/dnlp_vs_pypower/demo.py", + "presentations/weekly_update_20260826/cvxopf_project_update.synctex(busy)", + "presentations/weekly_update_20260826/cvxopf_project_update.tex" + ], + "reason": "During the final 8760-step worker, the experiment owner corrected an older DNLP experiment while preparing the project presentation. These files are outside the frozen M14 execution-source registry; the execution commit and M14 source fingerprint remained unchanged.", + "reviewed_on": "2026-08-26", + "schema_version": 1, + "scope": "non_execution_worktree_changes" +} diff --git a/experiments/m14_time_vectorization/M14A_PROTOCOL.md b/experiments/m14_time_vectorization/M14A_PROTOCOL.md index d80c097..a4e1f69 100644 --- a/experiments/m14_time_vectorization/M14A_PROTOCOL.md +++ b/experiments/m14_time_vectorization/M14A_PROTOCOL.md @@ -63,11 +63,16 @@ form one comparable baseline. The compact result retains readable source and canonical structures, objectives and component-cost scalars, artifact sizes, and their corresponding digests; ignored raw artifacts are not required to interpret the baseline. -Authoritative advancement and promotion additionally require clean parent and -worker provenance plus a clean analyzer from that exact execution commit and -source fingerprint. A numerically complete dirty-worktree run remains evidence -but is not the frozen M14a record. Worker return codes, classifications, and -artifact availability must also match the frozen supervisor outcome matrix. +Authoritative advancement and promotion normally require clean parent and +worker provenance. A reviewed exception may qualify a dirty worker only when +the parent launched clean, the execution commit and M14 source fingerprint +remain unchanged, and an explicit retained record names the non-execution +paths and scientific reason. The dirty worker remains visible in the compact +result. Post-execution analysis may use a later clean committed analyzer when +its own commit and source fingerprint are retained separately; correcting an +analyzer never rewrites execution provenance. Worker return codes, +classifications, and artifact availability must also match the frozen +supervisor outcome matrix. An unsuccessful point and the intentionally omitted later points remain valid partial characterization evidence but cannot be labeled a complete M14a baseline or authorize M14b advancement. @@ -85,6 +90,8 @@ uv run python -m experiments.m14_time_vectorization.run_m14a \ uv run python -m experiments.m14_time_vectorization.m14a_analysis \ experiments/m14_time_vectorization/results/m14a-case9 \ experiments/m14_time_vectorization/results/m14a-case118 \ + --reviewed-worktree-exception \ + experiments/m14_time_vectorization/M14A_EXECUTION_REVIEW.json \ --promote experiments/m14_time_vectorization/M14A_RESULTS.json ``` diff --git a/experiments/m14_time_vectorization/m14a_analysis.py b/experiments/m14_time_vectorization/m14a_analysis.py index b191cf1..8d9ecb2 100644 --- a/experiments/m14_time_vectorization/m14a_analysis.py +++ b/experiments/m14_time_vectorization/m14a_analysis.py @@ -55,7 +55,9 @@ def _digest(value: object) -> str: def _analysis_source_fingerprint() -> str: digest = hashlib.sha256() - for path in sorted(ANALYSIS_SOURCES): + # Match run_m14a._source_fingerprint(): package sources first, followed by + # experiment sources. Re-sorting the combined tuple changes the digest. + for path in ANALYSIS_SOURCES: digest.update(path.relative_to(ROOT).as_posix().encode()) digest.update(b"\0") digest.update(path.read_bytes()) @@ -235,6 +237,7 @@ def analyze_run(directory: Path) -> dict[str, Any]: summaries: list[dict[str, Any]] = [] complete = True provenance_clean = context.get("worktree_clean") is True + dirty_worker_points: list[dict[str, Any]] = [] for raw_record in records: if not isinstance(raw_record, dict): raise ValueError("manifest record must be a mapping") @@ -303,6 +306,16 @@ def analyze_run(directory: Path) -> dict[str, Any]: provenance_clean = ( provenance_clean and payload_context.get("worktree_clean") is True ) + if payload_context.get("worktree_clean") is not True: + dirty_worker_points.append( + { + "case": case_name, + "formulation": formulation, + "horizon": horizon, + "git_commit": payload_context.get("git_commit"), + "source_fingerprint": payload_context.get("source_fingerprint"), + } + ) if ( payload.get("case"), payload.get("formulation"), @@ -396,7 +409,9 @@ def analyze_run(directory: Path) -> dict[str, Any]: "stage": "M14a_legacy_baseline", "frozen_ladder": ladder, "execution_complete": complete, + "execution_provenance_clean": provenance_clean, "accepted_as_ladder_record": accepted_as_ladder_record, + "dirty_worker_points": dirty_worker_points, "audit_tolerance": AUDIT_TOLERANCE, "execution_context": context, "analysis_context": { @@ -412,7 +427,68 @@ def analyze_run(directory: Path) -> dict[str, Any]: } -def analyze_runs(directories: list[Path]) -> dict[str, Any]: +def _validate_reviewed_worktree_exception( + exception: object, + *, + contexts: list[dict[str, Any]], + dirty_worker_points: list[dict[str, Any]], +) -> dict[str, Any]: + if not isinstance(exception, dict): + raise ValueError("reviewed worktree exception must be a mapping") + if exception.get("schema_version") != 1: + raise ValueError("unsupported reviewed worktree exception schema") + if exception.get("scope") != "non_execution_worktree_changes": + raise ValueError("reviewed worktree exception scope is invalid") + reason = exception.get("reason") + if not isinstance(reason, str) or not reason.strip(): + raise ValueError("reviewed worktree exception reason is missing") + paths = exception.get("paths") + if ( + not isinstance(paths, list) + or not paths + or not all(isinstance(path, str) and path for path in paths) + or len(set(paths)) != len(paths) + ): + raise ValueError("reviewed worktree exception paths are invalid") + normalized_paths: list[str] = [] + for raw_path in paths: + candidate = Path(raw_path) + if ( + candidate.is_absolute() + or not candidate.parts + or candidate == Path(".") + or ".." in candidate.parts + or candidate != Path(*candidate.parts) + ): + raise ValueError("reviewed worktree exception path is not normalized") + normalized = candidate.as_posix() + if normalized.startswith("src/cvxopf/") or normalized.startswith( + "experiments/m14_time_vectorization/" + ): + raise ValueError("reviewed exception includes an execution-source path") + normalized_paths.append(normalized) + if not dirty_worker_points: + raise ValueError("reviewed exception has no dirty worker to explain") + if any(context.get("worktree_clean") is not True for context in contexts): + raise ValueError("reviewed exception requires clean parent launch contexts") + for name in ("execution_commit", "execution_source_fingerprint"): + context_name = ( + "git_commit" if name == "execution_commit" else "source_fingerprint" + ) + if exception.get(name) != contexts[0].get(context_name): + raise ValueError(f"reviewed worktree exception {name} mismatch") + return { + **exception, + "paths": sorted(normalized_paths), + "dirty_worker_points": dirty_worker_points, + } + + +def analyze_runs( + directories: list[Path], + *, + reviewed_worktree_exception: dict[str, Any] | None = None, +) -> dict[str, Any]: """Combine the two frozen ladders into the M14a advancement record.""" runs: dict[str, dict[str, Any]] = {} for directory in directories: @@ -427,28 +503,43 @@ def analyze_runs(directories: list[Path]) -> dict[str, Any]: for name in ("git_commit", "source_fingerprint", *ENVIRONMENT_FIELDS): if any(context.get(name) != contexts[0].get(name) for context in contexts[1:]): raise ValueError(f"M14a ladder {name} values do not match") + dirty_worker_points = [ + point for run in runs.values() for point in run["dirty_worker_points"] + ] + execution_complete = all(run["execution_complete"] for run in runs.values()) + execution_provenance_accepted = all( + run["execution_provenance_clean"] for run in runs.values() + ) + reviewed_exception = None + if reviewed_worktree_exception is not None: + reviewed_exception = _validate_reviewed_worktree_exception( + reviewed_worktree_exception, + contexts=contexts, + dirty_worker_points=dirty_worker_points, + ) + execution_provenance_accepted = True analysis_context = { "git_commit": _git("rev-parse", "HEAD"), "worktree_clean": _git("status", "--porcelain") == "", "source_fingerprint": _analysis_source_fingerprint(), } - analysis_matches_execution = ( + analysis_provenance_accepted = ( analysis_context["worktree_clean"] is True - and analysis_context["git_commit"] == contexts[0].get("git_commit") - and analysis_context["source_fingerprint"] - == contexts[0].get("source_fingerprint") + and isinstance(analysis_context["git_commit"], str) + and bool(analysis_context["git_commit"]) + and len(str(analysis_context["source_fingerprint"])) == 64 ) return { "schema_version": 1, "stage": "M14a_legacy_baseline", - "execution_complete": all(run["execution_complete"] for run in runs.values()), - "accepted_for_m14b": all( - run["accepted_as_ladder_record"] for run in runs.values() - ) - and analysis_matches_execution, + "execution_complete": execution_complete, + "accepted_for_m14b": execution_complete + and execution_provenance_accepted + and analysis_provenance_accepted, "execution_commit": contexts[0].get("git_commit"), "execution_source_fingerprint": contexts[0].get("source_fingerprint"), "analysis_context": analysis_context, + "reviewed_worktree_exception": reviewed_exception, "ladders": runs, } @@ -461,9 +552,10 @@ def _promote(path: Path, payload: dict[str, Any]) -> None: analysis_context = payload.get("analysis_context") if not isinstance(analysis_context, dict) or ( analysis_context.get("worktree_clean") is not True - or analysis_context.get("git_commit") != payload.get("execution_commit") - or analysis_context.get("source_fingerprint") - != payload.get("execution_source_fingerprint") + or not isinstance(analysis_context.get("git_commit"), str) + or not analysis_context.get("git_commit") + or not isinstance(analysis_context.get("source_fingerprint"), str) + or len(analysis_context["source_fingerprint"]) != 64 ): raise ValueError("analysis provenance does not match the execution source") data = ( @@ -481,8 +573,18 @@ def main() -> None: parser = argparse.ArgumentParser() parser.add_argument("run_directories", type=Path, nargs="+") parser.add_argument("--promote", type=Path) + parser.add_argument("--reviewed-worktree-exception", type=Path) arguments = parser.parse_args() - result = analyze_runs(arguments.run_directories) + reviewed_exception = None + if arguments.reviewed_worktree_exception is not None: + reviewed_exception = cast( + dict[str, Any], + json.loads(arguments.reviewed_worktree_exception.read_text()), + ) + result = analyze_runs( + arguments.run_directories, + reviewed_worktree_exception=reviewed_exception, + ) if arguments.promote is not None: _promote(arguments.promote, result) print(json.dumps(result, sort_keys=True, indent=2, allow_nan=False)) diff --git a/tests/test_m14a_analysis.py b/tests/test_m14a_analysis.py index 222a9e2..d9f20a6 100644 --- a/tests/test_m14a_analysis.py +++ b/tests/test_m14a_analysis.py @@ -9,11 +9,13 @@ from experiments.m14_time_vectorization import run_m14a from experiments.m14_time_vectorization.m14a_analysis import ( + _analysis_source_fingerprint, _promote, _validate_classification_record, analyze_run, analyze_runs, ) +from experiments.m14_time_vectorization.run_m14a import _source_fingerprint def _small_frozen_ladder(monkeypatch: pytest.MonkeyPatch) -> None: @@ -150,10 +152,10 @@ def test_complete_promotion_is_immutable(tmp_path: Path): "execution_complete": True, "accepted_for_m14b": True, "execution_commit": "commit", - "execution_source_fingerprint": "source", + "execution_source_fingerprint": "s" * 64, "analysis_context": { "git_commit": "commit", - "source_fingerprint": "source", + "source_fingerprint": "a" * 64, "worktree_clean": True, }, "value": 1, @@ -184,11 +186,20 @@ def test_consolidation_requires_both_frozen_ladders( analyze_runs([output]) -def _synthetic_run(ladder: str, *, platform: str = "platform") -> dict: +def _synthetic_run( + ladder: str, + *, + platform: str = "platform", + accepted: bool = True, + execution_complete: bool = True, + dirty_worker_points: list[dict] | None = None, +) -> dict: return { "frozen_ladder": ladder, - "execution_complete": True, - "accepted_as_ladder_record": True, + "execution_complete": execution_complete, + "execution_provenance_clean": accepted, + "accepted_as_ladder_record": execution_complete and accepted, + "dirty_worker_points": dirty_worker_points or [], "execution_context": { "git_commit": "commit", "source_fingerprint": "source", @@ -216,7 +227,7 @@ def test_complete_consolidation_requires_matched_environment( "_git", lambda *args: "" if args == ("status", "--porcelain") else "commit", ) - monkeypatch.setattr(analysis, "_analysis_source_fingerprint", lambda: "source") + monkeypatch.setattr(analysis, "_analysis_source_fingerprint", lambda: "a" * 64) result = analyze_runs([tmp_path / "case9", tmp_path / "case118"]) assert result["execution_complete"] is True @@ -249,6 +260,106 @@ def test_dirty_analysis_cannot_advance_or_promote( _promote(tmp_path / "result.json", result) +def test_reviewed_nonexecution_changes_qualify_dirty_worker( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +): + import experiments.m14_time_vectorization.m14a_analysis as analysis + + dirty_point = { + "case": "case118", + "formulation": "singlenode_dc", + "horizon": 8760, + "git_commit": "commit", + "source_fingerprint": "source", + } + runs = { + "case9": _synthetic_run("case9"), + "case118": _synthetic_run( + "case118", accepted=False, dirty_worker_points=[dirty_point] + ), + } + monkeypatch.setattr(analysis, "analyze_run", lambda path: runs[path.name]) + monkeypatch.setattr( + analysis, + "_git", + lambda *args: "" if args == ("status", "--porcelain") else "analysis", + ) + monkeypatch.setattr(analysis, "_analysis_source_fingerprint", lambda: "a" * 64) + exception = { + "schema_version": 1, + "scope": "non_execution_worktree_changes", + "reason": "presentation preparation", + "paths": ["presentations/update.tex"], + "execution_commit": "commit", + "execution_source_fingerprint": "source", + } + + result = analyze_runs( + [tmp_path / "case9", tmp_path / "case118"], + reviewed_worktree_exception=exception, + ) + + assert result["accepted_for_m14b"] is True + assert result["reviewed_worktree_exception"]["dirty_worker_points"] == [dirty_point] + + exception["paths"] = ["experiments/m14_time_vectorization/run_m14a.py"] + with pytest.raises(ValueError, match="execution-source path"): + analyze_runs( + [tmp_path / "case9", tmp_path / "case118"], + reviewed_worktree_exception=exception, + ) + + +def test_reviewed_dirty_worker_exception_does_not_qualify_incomplete_ladder( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +): + import experiments.m14_time_vectorization.m14a_analysis as analysis + + dirty_point = { + "case": "case118", + "formulation": "singlenode_dc", + "horizon": 8760, + "git_commit": "commit", + "source_fingerprint": "source", + } + runs = { + "case9": _synthetic_run("case9"), + "case118": _synthetic_run( + "case118", + accepted=False, + execution_complete=False, + dirty_worker_points=[dirty_point], + ), + } + monkeypatch.setattr(analysis, "analyze_run", lambda path: runs[path.name]) + monkeypatch.setattr( + analysis, + "_git", + lambda *args: "" if args == ("status", "--porcelain") else "analysis", + ) + monkeypatch.setattr(analysis, "_analysis_source_fingerprint", lambda: "a" * 64) + + result = analyze_runs( + [tmp_path / "case9", tmp_path / "case118"], + reviewed_worktree_exception={ + "schema_version": 1, + "scope": "non_execution_worktree_changes", + "reason": "presentation preparation", + "paths": ["presentations/update.tex"], + "execution_commit": "commit", + "execution_source_fingerprint": "source", + }, + ) + + assert result["execution_complete"] is False + assert result["accepted_for_m14b"] is False + assert result["reviewed_worktree_exception"] is not None + + +def test_analysis_fingerprint_uses_execution_source_order(): + assert _analysis_source_fingerprint() == _source_fingerprint() + + @pytest.mark.parametrize( "record", [ From 0e5aaf76987367228126756c7be0336823cfd3e2 Mon Sep 17 00:00:00 2001 From: Bennet Meyers Date: Thu, 27 Aug 2026 14:37:19 -0700 Subject: [PATCH 15/28] results(m14a): record legacy scaling baseline Promote the independently reconstructed Case9 and Case118 ladder results. The record preserves execution and analysis provenance, documents the reviewed non-execution worktree exception, and authorizes advancement to M14b. --- .../m14_time_vectorization/M14A_RESULTS.json | 266882 +++++++++++++++ 1 file changed, 266882 insertions(+) create mode 100644 experiments/m14_time_vectorization/M14A_RESULTS.json diff --git a/experiments/m14_time_vectorization/M14A_RESULTS.json b/experiments/m14_time_vectorization/M14A_RESULTS.json new file mode 100644 index 0000000..7948e85 --- /dev/null +++ b/experiments/m14_time_vectorization/M14A_RESULTS.json @@ -0,0 +1,266882 @@ +{ + "accepted_for_m14b": true, + "analysis_context": { + "git_commit": "457ec9200050eae2a60dd470a131155a0ddaa53f", + "source_fingerprint": "f8c1768f3afd560171981c412202d6f10d4d42c5368a024070971504874cfbfd", + "worktree_clean": true + }, + "execution_commit": "1dd5e36dcae5ad9c8176b1d1202f1055acf95c03", + "execution_complete": true, + "execution_source_fingerprint": "02567a6928cede7d51d555affb84107e480a87adf748676f0e2ed2e598232e1b", + "ladders": { + "case118": { + "accepted_as_ladder_record": false, + "analysis_context": { + "git_commit": "457ec9200050eae2a60dd470a131155a0ddaa53f", + "source_fingerprint": "f8c1768f3afd560171981c412202d6f10d4d42c5368a024070971504874cfbfd", + "worktree_clean": true + }, + "audit_tolerance": 1e-05, + "dirty_worker_points": [ + { + "case": "case118", + "formulation": "singlenode_dc", + "git_commit": "1dd5e36dcae5ad9c8176b1d1202f1055acf95c03", + "horizon": 8760, + "source_fingerprint": "02567a6928cede7d51d555affb84107e480a87adf748676f0e2ed2e598232e1b" + } + ], + "execution_complete": true, + "execution_context": { + "git_commit": "1dd5e36dcae5ad9c8176b1d1202f1055acf95c03", + "machine": "arm64", + "packages": { + "clarabel": "0.11.1", + "cvxpy": "1.9.2", + "cyipopt": "1.7.0", + "ipopt": "3.14.19", + "numpy": "2.4.6", + "scipy": "1.17.1" + }, + "platform": "macOS-26.5.2-arm64-arm-64bit", + "python": "3.11.15", + "source_fingerprint": "02567a6928cede7d51d555affb84107e480a87adf748676f0e2ed2e598232e1b", + "worktree_clean": true + }, + "execution_provenance_clean": false, + "frozen_ladder": "case118", + "manifest": { + "bytes": 5095, + "sha256": "626bec840cfd1063660f59a1e164108e8d4177999e777d652bf110ed4f95e5e3" + }, + "points": [ + { + "artifact_bytes": 126011, + "artifact_sha256": "a2f990f209c5253401bdff5e9cd6840cfd0212d491c33ae5fc815dc78b6cfe1d", + "audit_inputs_sha256": "9695e98d826fea6a0024d3967e8d2a45dba676cc904088ddee7ad9d6ec9c5f1b", + "canonical_structure": null, + "canonical_structure_sha256": "74234e98afe7498fb5daf1f36ac2d78acc339464f950703b8c019892f982b90b", + "case": "case118", + "classification": "completed", + "formulation": "ac", + "horizon": 1, + "log_sha256": "9f86dfcc7341773aa0eaecd34ba358bd0a94e73d1d4edd11abf856e06fba969d", + "maximum_residual": 5.684341886080802e-14, + "peak_rss_bytes": { + "after_canonicalization": null, + "after_construction": 165675008, + "after_extraction": 1320042496, + "after_solve": 1320042496 + }, + "phase_journal_sha256": "185331521c4f8224b6441f83b246d40d915f962260750ac5ca25e7e51eeba5c3", + "result_schema_sha256": "1b07e6917216a8699b2b581dc21d56d7211734b59f7d6742809960a18ad6ab6d", + "result_sha256": "d6ba2a37496ef63fc53968e9daaca9823a74e855463331421eb7dc3ba278d6a5", + "returncode": 0, + "scientific_scalars": { + "objective": 129660.05131659016, + "storage_cost": 2.1019353580052447e-17 + }, + "serialized_result_bytes": 33653, + "source_structure": { + "constraint_object_count": 1342, + "data_keys": [ + "B", + "B_vec", + "Cg", + "Cload", + "Cs", + "E", + "G", + "G_vec", + "Pd_series", + "Pgmax", + "Pgmin", + "Qd_series", + "Qgmax", + "Qgmin", + "Rp", + "T", + "Ybus", + "Z", + "baseMVA", + "branch_from_bus_external", + "branch_from_bus_internal", + "branch_rate_a_mva", + "branch_status", + "branch_to_bus_external", + "branch_to_bus_internal", + "cols", + "constrained_branch_indices", + "ext_to_int", + "gen_bus", + "gencost", + "load_bus_external", + "load_bus_internal", + "load_device_ids", + "load_has_reactive", + "load_is_sheddable", + "load_max_shed_fraction", + "load_shedding_cost_per_mwh", + "nb", + "ng", + "nl", + "nload", + "ns", + "nsheddable", + "pv", + "ref", + "rows", + "sheddable_load_device_ids", + "sheddable_load_indices", + "storage_aging_weight", + "storage_apparent_power_rating", + "storage_bus", + "storage_capacity", + "storage_delta", + "storage_device_id_is_explicit", + "storage_device_ids", + "storage_initial_soc", + "storage_terminal_constraint", + "storage_terminal_cost", + "storage_terminal_soc", + "storage_terminal_weight" + ], + "equality_object_count": 963, + "expression_schema": [ + { + "name": "branch_p_from_pu", + "shapes": [ + [ + 186 + ] + ] + }, + { + "name": "branch_p_to_pu", + "shapes": [ + [ + 186 + ] + ] + }, + { + "name": "branch_q_from_pu", + "shapes": [ + [ + 186 + ] + ] + }, + { + "name": "branch_q_to_pu", + "shapes": [ + [ + 186 + ] + ] + }, + { + "name": "generator_cost", + "shapes": [ + [] + ] + }, + { + "name": "p_load", + "shapes": [ + [ + 118 + ] + ] + }, + { + "name": "p_load_served", + "shapes": [ + [ + 118 + ] + ] + }, + { + "name": "p_net", + "shapes": [ + [ + 118 + ] + ] + }, + { + "name": "q_load", + "shapes": [ + [ + 118 + ] + ] + }, + { + "name": "q_load_served", + "shapes": [ + [ + 118 + ] + ] + }, + { + "name": "q_net", + "shapes": [ + [ + 118 + ] + ] + }, + { + "name": "storage_cost", + "shapes": [ + [] + ] + } + ], + "formulation": "ac", + "horizon": 1, + "inequality_object_count": 379, + "other_constraint_object_count": 0, + "parameter_object_count": 2, + "parameter_schema": [ + { + "name": "load_inv_base_mva", + "shapes": [ + [] + ] + }, + { + "name": "storage_inv_baseMVA", + "shapes": [ + [] + ] + } + ], + "parameter_shapes": [ + [], + [] + ], + "scalar_data": 158989, + "scalar_equalities": 2171, + "scalar_inequalities": 591, + "scalar_variables": 2279, + "temporal_assembly": "stepwise", + "variable_object_count": 15, + "variable_schema": [ + { + "name": "P_vec", + "shapes": [ + [ + 476 + ] + ] + }, + { + "name": "Pg", + "shapes": [ + [ + 54 + ] + ] + }, + { + "name": "Q_vec", + "shapes": [ + [ + 476 + ] + ] + }, + { + "name": "Qg", + "shapes": [ + [ + 54 + ] + ] + }, + { + "name": "b", + "shapes": [ + [ + 1 + ] + ] + }, + { + "name": "b_q", + "shapes": [ + [ + 1 + ] + ] + }, + { + "name": "p", + "shapes": [ + [ + 118 + ] + ] + }, + { + "name": "q", + "shapes": [ + [ + 118 + ] + ] + }, + { + "name": "soc", + "shapes": [ + [ + 1 + ] + ] + }, + { + "name": "theta", + "shapes": [ + [ + 118, + 1 + ] + ] + }, + { + "name": "v", + "shapes": [ + [ + 118, + 1 + ] + ] + } + ] + }, + "source_structure_sha256": "9432a9d20c682691f1a9b1c6fae31ecda085235ce1452cd3c66a7f08e98a1515", + "timing_seconds": { + "canonicalization": null, + "construction": 0.20680975000141189, + "extraction": 0.00013508298434317112, + "solve_after_explicit_canonicalization": 3.5901574169984087 + } + }, + { + "artifact_bytes": 192692, + "artifact_sha256": "0646b892aa0287f3a5a36bd8875ce918b88d4f8abc1ce010fa7ebf69aa54f53f", + "audit_inputs_sha256": "9695e98d826fea6a0024d3967e8d2a45dba676cc904088ddee7ad9d6ec9c5f1b", + "canonical_structure": null, + "canonical_structure_sha256": "74234e98afe7498fb5daf1f36ac2d78acc339464f950703b8c019892f982b90b", + "case": "case118", + "classification": "completed", + "formulation": "ac", + "horizon": 3, + "log_sha256": "9f86dfcc7341773aa0eaecd34ba358bd0a94e73d1d4edd11abf856e06fba969d", + "maximum_residual": 5.684341886080802e-14, + "peak_rss_bytes": { + "after_canonicalization": null, + "after_construction": 205127680, + "after_extraction": 8810184704, + "after_solve": 8810184704 + }, + "phase_journal_sha256": "cf52ce7d9d64e9d77b9fcdcd3f184420bd61e25b51b0405b492c15f75ab921a3", + "result_schema_sha256": "0b12655ed736380ceaf675c4b86910576b8f14ece9592c87e1dead54e01899bf", + "result_sha256": "28c928f842abdf1a577d8026a5fe22a18aebbac3e585d5b827ac35f7a8993dcd", + "returncode": 0, + "scientific_scalars": { + "objective": 388980.1539479963, + "storage_cost": 2.949036557832575e-15 + }, + "serialized_result_bytes": 100046, + "source_structure": { + "constraint_object_count": 4024, + "data_keys": [ + "B", + "B_vec", + "Cg", + "Cload", + "Cs", + "E", + "G", + "G_vec", + "Pd_series", + "Pgmax", + "Pgmin", + "Qd_series", + "Qgmax", + "Qgmin", + "Rp", + "T", + "Ybus", + "Z", + "baseMVA", + "branch_from_bus_external", + "branch_from_bus_internal", + "branch_rate_a_mva", + "branch_status", + "branch_to_bus_external", + "branch_to_bus_internal", + "cols", + "constrained_branch_indices", + "ext_to_int", + "gen_bus", + "gencost", + "load_bus_external", + "load_bus_internal", + "load_device_ids", + "load_has_reactive", + "load_is_sheddable", + "load_max_shed_fraction", + "load_shedding_cost_per_mwh", + "nb", + "ng", + "nl", + "nload", + "ns", + "nsheddable", + "pv", + "ref", + "rows", + "sheddable_load_device_ids", + "sheddable_load_indices", + "storage_aging_weight", + "storage_apparent_power_rating", + "storage_bus", + "storage_capacity", + "storage_delta", + "storage_device_id_is_explicit", + "storage_device_ids", + "storage_initial_soc", + "storage_terminal_constraint", + "storage_terminal_cost", + "storage_terminal_soc", + "storage_terminal_weight" + ], + "equality_object_count": 2887, + "expression_schema": [ + { + "name": "branch_p_from_pu", + "shapes": [ + [ + 186 + ], + [ + 186 + ], + [ + 186 + ] + ] + }, + { + "name": "branch_p_to_pu", + "shapes": [ + [ + 186 + ], + [ + 186 + ], + [ + 186 + ] + ] + }, + { + "name": "branch_q_from_pu", + "shapes": [ + [ + 186 + ], + [ + 186 + ], + [ + 186 + ] + ] + }, + { + "name": "branch_q_to_pu", + "shapes": [ + [ + 186 + ], + [ + 186 + ], + [ + 186 + ] + ] + }, + { + "name": "generator_cost", + "shapes": [ + [] + ] + }, + { + "name": "p_load", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "p_load_served", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "p_net", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "q_load", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "q_load_served", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "q_net", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "storage_cost", + "shapes": [ + [] + ] + } + ], + "formulation": "ac", + "horizon": 3, + "inequality_object_count": 1137, + "other_constraint_object_count": 0, + "parameter_object_count": 6, + "parameter_schema": [ + { + "name": "load_inv_base_mva", + "shapes": [ + [], + [], + [] + ] + }, + { + "name": "storage_inv_baseMVA", + "shapes": [ + [], + [], + [] + ] + } + ], + "parameter_shapes": [ + [], + [], + [], + [], + [], + [] + ], + "scalar_data": 476961, + "scalar_equalities": 6511, + "scalar_inequalities": 1773, + "scalar_variables": 6837, + "temporal_assembly": "stepwise", + "variable_object_count": 45, + "variable_schema": [ + { + "name": "P_vec", + "shapes": [ + [ + 476 + ], + [ + 476 + ], + [ + 476 + ] + ] + }, + { + "name": "Pg", + "shapes": [ + [ + 54 + ], + [ + 54 + ], + [ + 54 + ] + ] + }, + { + "name": "Q_vec", + "shapes": [ + [ + 476 + ], + [ + 476 + ], + [ + 476 + ] + ] + }, + { + "name": "Qg", + "shapes": [ + [ + 54 + ], + [ + 54 + ], + [ + 54 + ] + ] + }, + { + "name": "b", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + }, + { + "name": "b_q", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + }, + { + "name": "p", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "q", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "soc", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + }, + { + "name": "theta", + "shapes": [ + [ + 118, + 1 + ], + [ + 118, + 1 + ], + [ + 118, + 1 + ] + ] + }, + { + "name": "v", + "shapes": [ + [ + 118, + 1 + ], + [ + 118, + 1 + ], + [ + 118, + 1 + ] + ] + } + ] + }, + "source_structure_sha256": "e03c3730fb854366d4559422b6158046ce3f32e9145d6ebfa2863a86d4d6f574", + "timing_seconds": { + "canonicalization": null, + "construction": 0.6636915000271983, + "extraction": 0.0002395409974269569, + "solve_after_explicit_canonicalization": 15.716459124989342 + } + }, + { + "artifact_bytes": 287994, + "artifact_sha256": "2bca5f50e2740747396487144846442a87ca8fcf1ec85c971582a2f9e946a83c", + "audit_inputs_sha256": "e108f984df6c53d74405e150e21d71f8188c3881f3d0c23f637dd395b943fede", + "canonical_structure": { + "backend": "CPP", + "canonical_variable_count": 11592, + "coefficient_columns": 11592, + "coefficient_nonzeros": 38016, + "coefficient_rows": 20281, + "equality_rows": 4153, + "exponential_cones": 0, + "formulation": "lossy_dc", + "nonnegative_rows": 16128, + "positive_semidefinite_cones": [], + "power_cones_3d": [], + "quadratic_nonzeros": 5544, + "reduction_chain": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "second_order_cones": [], + "solver": "CLARABEL", + "temporal_assembly": "stepwise" + }, + "canonical_structure_sha256": "b223f320c7206469ee9fdfeb6c19bbe7b050e524b1bbdf284bc5a487c64e8f76", + "case": "case118", + "classification": "completed", + "formulation": "lossy_dc", + "horizon": 24, + "log_sha256": "8f36b0e70807f72cc1befc5c3b6cee05de11fe0d7917168771ae727a36be63c0", + "maximum_residual": 5.684341886080802e-14, + "peak_rss_bytes": { + "after_canonicalization": 220905472, + "after_construction": 154812416, + "after_extraction": 234323968, + "after_solve": 234258432 + }, + "phase_journal_sha256": "91dedb6f516f7f1e59c792e6ff601a0b28de03fc713f5614ac21f39d7dbe7c5f", + "result_schema_sha256": "68b1a79b7f0c4c1a79c58100531c906ade91b687e5b664be567787f7e24a3c6a", + "result_sha256": "91075b769bbdba1ab6a79e1de2821c6a2d50f827bb9c34cd4acd9126813ca2d3", + "returncode": 0, + "scientific_scalars": { + "objective": 3022775.2091852436, + "storage_cost": 1.16613061810635e-14 + }, + "serialized_result_bytes": 195254, + "source_structure": { + "constraint_object_count": 217, + "data_keys": [ + "A", + "Cg", + "Cload", + "Cs", + "Pd_series", + "Pgmax", + "Pgmin", + "T", + "baseMVA", + "ext_to_int", + "f_max", + "gen_bus", + "gencost", + "load_bus_external", + "load_bus_internal", + "load_device_ids", + "load_has_reactive", + "load_is_sheddable", + "load_max_shed_fraction", + "load_shedding_cost_per_mwh", + "loss_weight", + "nb", + "ng", + "nl", + "nload", + "ns", + "nsheddable", + "r", + "sheddable_load_device_ids", + "sheddable_load_indices", + "storage_aging_weight", + "storage_apparent_power_rating", + "storage_bus", + "storage_capacity", + "storage_delta", + "storage_device_id_is_explicit", + "storage_device_ids", + "storage_initial_soc", + "storage_terminal_constraint", + "storage_terminal_cost", + "storage_terminal_soc", + "storage_terminal_weight" + ], + "equality_object_count": 49, + "expression_schema": [ + { + "name": "dc_loss_cost", + "shapes": [ + [] + ] + }, + { + "name": "generator_cost", + "shapes": [ + [] + ] + }, + { + "name": "p_load", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "p_load_served", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "p_net", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "q_load", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "storage_cost", + "shapes": [ + [] + ] + } + ], + "formulation": "lossy_dc", + "horizon": 24, + "inequality_object_count": 168, + "other_constraint_object_count": 0, + "parameter_object_count": 48, + "parameter_schema": [ + { + "name": "load_inv_base_mva", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ] + }, + { + "name": "storage_inv_baseMVA", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ] + } + ], + "parameter_shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + "scalar_data": 1033899, + "scalar_equalities": 2857, + "scalar_inequalities": 7152, + "scalar_variables": 5808, + "temporal_assembly": "stepwise", + "variable_object_count": 96, + "variable_schema": [ + { + "name": "Pg", + "shapes": [ + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ] + ] + }, + { + "name": "b", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + }, + { + "name": "p_flows", + "shapes": [ + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ] + ] + }, + { + "name": "soc", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + } + ] + }, + "source_structure_sha256": "402cb47dc0571de3e3016f1f28b3b11d63a933877deba9c486848932e62b65f1", + "timing_seconds": { + "canonicalization": 0.6877967920154333, + "construction": 0.14163212501443923, + "extraction": 0.0006985000218264759, + "solve_after_explicit_canonicalization": 0.07299100002273917 + } + }, + { + "artifact_bytes": 1465324, + "artifact_sha256": "4f98197bf07e90c5a41260e9435dce95e7fac83a485fe5dc43e3beeae77ac354", + "audit_inputs_sha256": "e108f984df6c53d74405e150e21d71f8188c3881f3d0c23f637dd395b943fede", + "canonical_structure": { + "backend": "CPP", + "canonical_variable_count": 81144, + "coefficient_columns": 81144, + "coefficient_nonzeros": 266112, + "coefficient_rows": 141961, + "equality_rows": 29065, + "exponential_cones": 0, + "formulation": "lossy_dc", + "nonnegative_rows": 112896, + "positive_semidefinite_cones": [], + "power_cones_3d": [], + "quadratic_nonzeros": 38808, + "reduction_chain": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "second_order_cones": [], + "solver": "CLARABEL", + "temporal_assembly": "stepwise" + }, + "canonical_structure_sha256": "a91b43ff82c82907a2dbdcc589ca772627670f963c7537c294a0f8fb0d801268", + "case": "case118", + "classification": "completed", + "formulation": "lossy_dc", + "horizon": 168, + "log_sha256": "8f36b0e70807f72cc1befc5c3b6cee05de11fe0d7917168771ae727a36be63c0", + "maximum_residual": 5.684341886080802e-14, + "peak_rss_bytes": { + "after_canonicalization": 881672192, + "after_construction": 210157568, + "after_extraction": 881672192, + "after_solve": 881672192 + }, + "phase_journal_sha256": "603bd4ebd553b2a83127f159badf2a4fdccf9c0d1202572911ca589698ef8983", + "result_schema_sha256": "b2ed720291946cbe87d4a1435c61a8510259400fcf97b43fe04b8d3ead4a7b53", + "result_sha256": "1e699a9bca5904984a92b23ea3a9e65922a28079882b105cd1494879156282c1", + "returncode": 0, + "scientific_scalars": { + "objective": 21159426.464300554, + "storage_cost": 7.195820158436042e-10 + }, + "serialized_result_bytes": 1364627, + "source_structure": { + "constraint_object_count": 1513, + "data_keys": [ + "A", + "Cg", + "Cload", + "Cs", + "Pd_series", + "Pgmax", + "Pgmin", + "T", + "baseMVA", + "ext_to_int", + "f_max", + "gen_bus", + "gencost", + "load_bus_external", + "load_bus_internal", + "load_device_ids", + "load_has_reactive", + "load_is_sheddable", + "load_max_shed_fraction", + "load_shedding_cost_per_mwh", + "loss_weight", + "nb", + "ng", + "nl", + "nload", + "ns", + "nsheddable", + "r", + "sheddable_load_device_ids", + "sheddable_load_indices", + "storage_aging_weight", + "storage_apparent_power_rating", + "storage_bus", + "storage_capacity", + "storage_delta", + "storage_device_id_is_explicit", + "storage_device_ids", + "storage_initial_soc", + "storage_terminal_constraint", + "storage_terminal_cost", + "storage_terminal_soc", + "storage_terminal_weight" + ], + "equality_object_count": 337, + "expression_schema": [ + { + "name": "dc_loss_cost", + "shapes": [ + [] + ] + }, + { + "name": "generator_cost", + "shapes": [ + [] + ] + }, + { + "name": "p_load", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "p_load_served", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "p_net", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "q_load", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "storage_cost", + "shapes": [ + [] + ] + } + ], + "formulation": "lossy_dc", + "horizon": 168, + "inequality_object_count": 1176, + "other_constraint_object_count": 0, + "parameter_object_count": 336, + "parameter_schema": [ + { + "name": "load_inv_base_mva", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ] + }, + { + "name": "storage_inv_baseMVA", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ] + } + ], + "parameter_shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + "scalar_data": 7237275, + "scalar_equalities": 19993, + "scalar_inequalities": 50064, + "scalar_variables": 40656, + "temporal_assembly": "stepwise", + "variable_object_count": 672, + "variable_schema": [ + { + "name": "Pg", + "shapes": [ + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ] + ] + }, + { + "name": "b", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + }, + { + "name": "p_flows", + "shapes": [ + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ] + ] + }, + { + "name": "soc", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + } + ] + }, + "source_structure_sha256": "7c3a18aeefdbc595d4b91dc67b833d84bc7d061d29b5e46e42f9b62a820d013d", + "timing_seconds": { + "canonicalization": 6.378471791977063, + "construction": 0.8854480840382166, + "extraction": 0.004948458983562887, + "solve_after_explicit_canonicalization": 0.520683208014816 + } + }, + { + "artifact_bytes": 5978328, + "artifact_sha256": "8eb4e1fb757ab18f61dc8f0842daa52efacb835ee527bcc45b4b7f0223f855d8", + "audit_inputs_sha256": "e108f984df6c53d74405e150e21d71f8188c3881f3d0c23f637dd395b943fede", + "canonical_structure": { + "backend": "CPP", + "canonical_variable_count": 347760, + "coefficient_columns": 347760, + "coefficient_nonzeros": 1140480, + "coefficient_rows": 608401, + "equality_rows": 124561, + "exponential_cones": 0, + "formulation": "lossy_dc", + "nonnegative_rows": 483840, + "positive_semidefinite_cones": [], + "power_cones_3d": [], + "quadratic_nonzeros": 166320, + "reduction_chain": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "second_order_cones": [], + "solver": "CLARABEL", + "temporal_assembly": "stepwise" + }, + "canonical_structure_sha256": "6b71d8d086e87eae2af9350672bc88522309fdf8bc8fe9928bbbec1acb4c1be5", + "case": "case118", + "classification": "completed", + "formulation": "lossy_dc", + "horizon": 720, + "log_sha256": "8f36b0e70807f72cc1befc5c3b6cee05de11fe0d7917168771ae727a36be63c0", + "maximum_residual": 5.684341886080802e-14, + "peak_rss_bytes": { + "after_canonicalization": 4478107648, + "after_construction": 424443904, + "after_extraction": 4478107648, + "after_solve": 4478107648 + }, + "phase_journal_sha256": "3ba1d8babd469a653deccfe1b5ca80565b964e79718e5b2acb44bfad250885a7", + "result_schema_sha256": "f0f809a3849b9cdba807772c4cd47f79bc203fcd723ae63467220ad1500bf906", + "result_sha256": "affc2fa288bf54a80a00600495eb1fe43266835f17e2b2d8221533bfc2885ae2", + "returncode": 0, + "scientific_scalars": { + "objective": 90683256.27562529, + "storage_cost": 4.2281150857000634e-08 + }, + "serialized_result_bytes": 5847274, + "source_structure": { + "constraint_object_count": 6481, + "data_keys": [ + "A", + "Cg", + "Cload", + "Cs", + "Pd_series", + "Pgmax", + "Pgmin", + "T", + "baseMVA", + "ext_to_int", + "f_max", + "gen_bus", + "gencost", + "load_bus_external", + "load_bus_internal", + "load_device_ids", + "load_has_reactive", + "load_is_sheddable", + "load_max_shed_fraction", + "load_shedding_cost_per_mwh", + "loss_weight", + "nb", + "ng", + "nl", + "nload", + "ns", + "nsheddable", + "r", + "sheddable_load_device_ids", + "sheddable_load_indices", + "storage_aging_weight", + "storage_apparent_power_rating", + "storage_bus", + "storage_capacity", + "storage_delta", + "storage_device_id_is_explicit", + "storage_device_ids", + "storage_initial_soc", + "storage_terminal_constraint", + "storage_terminal_cost", + "storage_terminal_soc", + "storage_terminal_weight" + ], + "equality_object_count": 1441, + "expression_schema": [ + { + "name": "dc_loss_cost", + "shapes": [ + [] + ] + }, + { + "name": "generator_cost", + "shapes": [ + [] + ] + }, + { + "name": "p_load", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "p_load_served", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "p_net", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "q_load", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "storage_cost", + "shapes": [ + [] + ] + } + ], + "formulation": "lossy_dc", + "horizon": 720, + "inequality_object_count": 5040, + "other_constraint_object_count": 0, + "parameter_object_count": 1440, + "parameter_schema": [ + { + "name": "load_inv_base_mva", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ] + }, + { + "name": "storage_inv_baseMVA", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ] + } + ], + "parameter_shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + "scalar_data": 31016883, + "scalar_equalities": 85681, + "scalar_inequalities": 214560, + "scalar_variables": 174240, + "temporal_assembly": "stepwise", + "variable_object_count": 2880, + "variable_schema": [ + { + "name": "Pg", + "shapes": [ + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ] + ] + }, + { + "name": "b", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + }, + { + "name": "p_flows", + "shapes": [ + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ], + [ + 186 + ] + ] + }, + { + "name": "soc", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + } + ] + }, + "source_structure_sha256": "4450b3f024000458b68407a33d19c8298f2fb9f734ef8495b6cd176e455796a4", + "timing_seconds": { + "canonicalization": 44.059144416998606, + "construction": 3.9725183750269935, + "extraction": 0.02110858296509832, + "solve_after_explicit_canonicalization": 2.3552326660137624 + } + }, + { + "artifact_bytes": 85570, + "artifact_sha256": "c6c854de18e6d6f2408a154b512a1167ef0b9f8c70bded24da4e173a2f62d0d3", + "audit_inputs_sha256": "f74e4e3de2c77df127d9f25a25d370c743194e2cad276b9d76b661508b72d172", + "canonical_structure": { + "backend": "CPP", + "canonical_variable_count": 2664, + "coefficient_columns": 2664, + "coefficient_nonzeros": 6768, + "coefficient_rows": 4081, + "equality_rows": 1345, + "exponential_cones": 0, + "formulation": "singlenode_dc", + "nonnegative_rows": 2736, + "positive_semidefinite_cones": [], + "power_cones_3d": [], + "quadratic_nonzeros": 1296, + "reduction_chain": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "second_order_cones": [], + "solver": "CLARABEL", + "temporal_assembly": "stepwise" + }, + "canonical_structure_sha256": "fe03cb797f21332faf8b5eab7d759cbeb63719df9d6f4ba9346455bbc534642e", + "case": "case118", + "classification": "completed", + "formulation": "singlenode_dc", + "horizon": 24, + "log_sha256": "1c36d558da588be6220369f8849d9eb0e3a1c3ba542b329d97acc58df6d7b764", + "maximum_residual": 1.2291159477222394e-12, + "peak_rss_bytes": { + "after_canonicalization": 209960960, + "after_construction": 155074560, + "after_extraction": 211845120, + "after_solve": 211845120 + }, + "phase_journal_sha256": "8729d1bd64db47f308b4ac4d56f587544d7980db41650a6cf893cfe7291d5eed", + "result_schema_sha256": "f87f966c221cf650a3c811c9329694f2b921dde69a6149934752d8f4a2404df8", + "result_sha256": "3ea459ec79533217b6f23af3171408490bd268c417dbaa51b582f66475279a90", + "returncode": 0, + "scientific_scalars": { + "objective": 3022748.945577368, + "storage_cost": 1.5980915840484575e-13 + }, + "serialized_result_bytes": 77160, + "source_structure": { + "constraint_object_count": 193, + "data_keys": [ + "Cg", + "Cload", + "Cs", + "Pd_series", + "Pgmax", + "Pgmin", + "T", + "baseMVA", + "ext_to_int", + "gen_bus", + "gencost", + "load_bus_external", + "load_bus_internal", + "load_device_ids", + "load_has_reactive", + "load_is_sheddable", + "load_max_shed_fraction", + "load_shedding_cost_per_mwh", + "nb", + "ng", + "nload", + "ns", + "nsheddable", + "sheddable_load_device_ids", + "sheddable_load_indices", + "source_nb", + "storage_aging_weight", + "storage_apparent_power_rating", + "storage_bus", + "storage_capacity", + "storage_delta", + "storage_device_id_is_explicit", + "storage_device_ids", + "storage_initial_soc", + "storage_terminal_constraint", + "storage_terminal_cost", + "storage_terminal_soc", + "storage_terminal_weight" + ], + "equality_object_count": 49, + "expression_schema": [ + { + "name": "generator_cost", + "shapes": [ + [] + ] + }, + { + "name": "p_load", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "p_load_served", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "p_net", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ] + }, + { + "name": "q_load", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "storage_cost", + "shapes": [ + [] + ] + } + ], + "formulation": "singlenode_dc", + "horizon": 24, + "inequality_object_count": 144, + "other_constraint_object_count": 0, + "parameter_object_count": 48, + "parameter_schema": [ + { + "name": "load_inv_base_mva", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ] + }, + { + "name": "storage_inv_baseMVA", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ] + } + ], + "parameter_shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + "scalar_data": 12411, + "scalar_equalities": 49, + "scalar_inequalities": 2688, + "scalar_variables": 1344, + "temporal_assembly": "stepwise", + "variable_object_count": 72, + "variable_schema": [ + { + "name": "Pg", + "shapes": [ + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ] + ] + }, + { + "name": "b", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + }, + { + "name": "soc", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + } + ] + }, + "source_structure_sha256": "547dd306029e6adc05fd6272877db956c55b4f65f96fe9b6b1122157d3782bf2", + "timing_seconds": { + "canonicalization": 0.6467265840037726, + "construction": 0.11176762502873316, + "extraction": 0.0005673749838024378, + "solve_after_explicit_canonicalization": 0.0292139999801293 + } + }, + { + "artifact_bytes": 553283, + "artifact_sha256": "f30ca7e44703473161ce71ffbbeb97dcdd426f789cc40d52e88d1d3a5032c500", + "audit_inputs_sha256": "f74e4e3de2c77df127d9f25a25d370c743194e2cad276b9d76b661508b72d172", + "canonical_structure": { + "backend": "CPP", + "canonical_variable_count": 18648, + "coefficient_columns": 18648, + "coefficient_nonzeros": 47376, + "coefficient_rows": 28561, + "equality_rows": 9409, + "exponential_cones": 0, + "formulation": "singlenode_dc", + "nonnegative_rows": 19152, + "positive_semidefinite_cones": [], + "power_cones_3d": [], + "quadratic_nonzeros": 9072, + "reduction_chain": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "second_order_cones": [], + "solver": "CLARABEL", + "temporal_assembly": "stepwise" + }, + "canonical_structure_sha256": "f2c3a5b489040fd33f15cfc71625a88f4cd85063e4eda1c0610ff2aee271aad2", + "case": "case118", + "classification": "completed", + "formulation": "singlenode_dc", + "horizon": 168, + "log_sha256": "1c36d558da588be6220369f8849d9eb0e3a1c3ba542b329d97acc58df6d7b764", + "maximum_residual": 1.9510575381025705e-12, + "peak_rss_bytes": { + "after_canonicalization": 619593728, + "after_construction": 207519744, + "after_extraction": 619593728, + "after_solve": 619593728 + }, + "phase_journal_sha256": "7937116c7f9f4b71d28d2bb7dad204419e317a6c729b43efe444a2470fa641de", + "result_schema_sha256": "d58e5fdd5fe1d1b4f6e92b7c79e972882c9291dc0635537caea92eb9fb61717c", + "result_sha256": "812c17b244d34faa6a6a165590ab05ed5e9a4906a86de8103e5bf3170f543245", + "returncode": 0, + "scientific_scalars": { + "objective": 21159242.61903658, + "storage_cost": 1.894227318251163e-12 + }, + "serialized_result_bytes": 538247, + "source_structure": { + "constraint_object_count": 1345, + "data_keys": [ + "Cg", + "Cload", + "Cs", + "Pd_series", + "Pgmax", + "Pgmin", + "T", + "baseMVA", + "ext_to_int", + "gen_bus", + "gencost", + "load_bus_external", + "load_bus_internal", + "load_device_ids", + "load_has_reactive", + "load_is_sheddable", + "load_max_shed_fraction", + "load_shedding_cost_per_mwh", + "nb", + "ng", + "nload", + "ns", + "nsheddable", + "sheddable_load_device_ids", + "sheddable_load_indices", + "source_nb", + "storage_aging_weight", + "storage_apparent_power_rating", + "storage_bus", + "storage_capacity", + "storage_delta", + "storage_device_id_is_explicit", + "storage_device_ids", + "storage_initial_soc", + "storage_terminal_constraint", + "storage_terminal_cost", + "storage_terminal_soc", + "storage_terminal_weight" + ], + "equality_object_count": 337, + "expression_schema": [ + { + "name": "generator_cost", + "shapes": [ + [] + ] + }, + { + "name": "p_load", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "p_load_served", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "p_net", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ] + }, + { + "name": "q_load", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "storage_cost", + "shapes": [ + [] + ] + } + ], + "formulation": "singlenode_dc", + "horizon": 168, + "inequality_object_count": 1008, + "other_constraint_object_count": 0, + "parameter_object_count": 336, + "parameter_schema": [ + { + "name": "load_inv_base_mva", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ] + }, + { + "name": "storage_inv_baseMVA", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ] + } + ], + "parameter_shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + "scalar_data": 86859, + "scalar_equalities": 337, + "scalar_inequalities": 18816, + "scalar_variables": 9408, + "temporal_assembly": "stepwise", + "variable_object_count": 504, + "variable_schema": [ + { + "name": "Pg", + "shapes": [ + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ] + ] + }, + { + "name": "b", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + }, + { + "name": "soc", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + } + ] + }, + "source_structure_sha256": "542fa660623e597c824902d13c5bce01c6acccb6f85cdab36222f4b1ed6fea29", + "timing_seconds": { + "canonicalization": 5.628774499986321, + "construction": 0.874971832963638, + "extraction": 0.0033749169670045376, + "solve_after_explicit_canonicalization": 0.20656787499319762 + } + }, + { + "artifact_bytes": 2347182, + "artifact_sha256": "a45570130704e2751fa8a11f868001e3cc95d26b47b8db25c6d9fb1f0017eb55", + "audit_inputs_sha256": "f74e4e3de2c77df127d9f25a25d370c743194e2cad276b9d76b661508b72d172", + "canonical_structure": { + "backend": "CPP", + "canonical_variable_count": 79920, + "coefficient_columns": 79920, + "coefficient_nonzeros": 203040, + "coefficient_rows": 122401, + "equality_rows": 40321, + "exponential_cones": 0, + "formulation": "singlenode_dc", + "nonnegative_rows": 82080, + "positive_semidefinite_cones": [], + "power_cones_3d": [], + "quadratic_nonzeros": 38880, + "reduction_chain": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "second_order_cones": [], + "solver": "CLARABEL", + "temporal_assembly": "stepwise" + }, + "canonical_structure_sha256": "d7fa257257441aa3870c8a72a0ca5653bea3601c30b92e1aaacfb729ef762d43", + "case": "case118", + "classification": "completed", + "formulation": "singlenode_dc", + "horizon": 720, + "log_sha256": "1c36d558da588be6220369f8849d9eb0e3a1c3ba542b329d97acc58df6d7b764", + "maximum_residual": 3.5401914261025846e-12, + "peak_rss_bytes": { + "after_canonicalization": 2955837440, + "after_construction": 415580160, + "after_extraction": 2955837440, + "after_solve": 2955837440 + }, + "phase_journal_sha256": "14a54b0026413c3d90955aaef36290c922dc302258aa8c16591190c1533d8286", + "result_schema_sha256": "6537482863384cdd2a2a10b641774c8b427ce5aa51bee970e28320eb07c40bc4", + "result_sha256": "259255555c58b9ca7768d0a9d0bdcfafa5b8d562147456d3cddbdcc13cc2d3cb", + "returncode": 0, + "scientific_scalars": { + "objective": 90682468.36727114, + "storage_cost": 7.861839734555538e-09 + }, + "serialized_result_bytes": 2306723, + "source_structure": { + "constraint_object_count": 5761, + "data_keys": [ + "Cg", + "Cload", + "Cs", + "Pd_series", + "Pgmax", + "Pgmin", + "T", + "baseMVA", + "ext_to_int", + "gen_bus", + "gencost", + "load_bus_external", + "load_bus_internal", + "load_device_ids", + "load_has_reactive", + "load_is_sheddable", + "load_max_shed_fraction", + "load_shedding_cost_per_mwh", + "nb", + "ng", + "nload", + "ns", + "nsheddable", + "sheddable_load_device_ids", + "sheddable_load_indices", + "source_nb", + "storage_aging_weight", + "storage_apparent_power_rating", + "storage_bus", + "storage_capacity", + "storage_delta", + "storage_device_id_is_explicit", + "storage_device_ids", + "storage_initial_soc", + "storage_terminal_constraint", + "storage_terminal_cost", + "storage_terminal_soc", + "storage_terminal_weight" + ], + "equality_object_count": 1441, + "expression_schema": [ + { + "name": "generator_cost", + "shapes": [ + [] + ] + }, + { + "name": "p_load", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "p_load_served", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "p_net", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ] + }, + { + "name": "q_load", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "storage_cost", + "shapes": [ + [] + ] + } + ], + "formulation": "singlenode_dc", + "horizon": 720, + "inequality_object_count": 4320, + "other_constraint_object_count": 0, + "parameter_object_count": 1440, + "parameter_schema": [ + { + "name": "load_inv_base_mva", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ] + }, + { + "name": "storage_inv_baseMVA", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ] + } + ], + "parameter_shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + "scalar_data": 372243, + "scalar_equalities": 1441, + "scalar_inequalities": 80640, + "scalar_variables": 40320, + "temporal_assembly": "stepwise", + "variable_object_count": 2160, + "variable_schema": [ + { + "name": "Pg", + "shapes": [ + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ] + ] + }, + { + "name": "b", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + }, + { + "name": "soc", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + } + ] + }, + "source_structure_sha256": "37c7eb684833b627f19ff0b6914ab754fce41f1076e473b33c5d03d1bdc9a906", + "timing_seconds": { + "canonicalization": 32.29869887500536, + "construction": 3.9050732089672238, + "extraction": 0.014980791020207107, + "solve_after_explicit_canonicalization": 0.9146512079751119 + } + }, + { + "artifact_bytes": 28321816, + "artifact_sha256": "3070db75b960fc901073db4e668e1c899e4b8d5a7e42f4776ad7793113a0c8ae", + "audit_inputs_sha256": "f74e4e3de2c77df127d9f25a25d370c743194e2cad276b9d76b661508b72d172", + "canonical_structure": { + "backend": "CPP", + "canonical_variable_count": 972360, + "coefficient_columns": 972360, + "coefficient_nonzeros": 2470320, + "coefficient_rows": 1489201, + "equality_rows": 490561, + "exponential_cones": 0, + "formulation": "singlenode_dc", + "nonnegative_rows": 998640, + "positive_semidefinite_cones": [], + "power_cones_3d": [], + "quadratic_nonzeros": 473040, + "reduction_chain": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "second_order_cones": [], + "solver": "CLARABEL", + "temporal_assembly": "stepwise" + }, + "canonical_structure_sha256": "4974169c785aeefe0d0599e8067969df9c9b8fbb0e04d445a02f9ca4e7d147cd", + "case": "case118", + "classification": "completed", + "formulation": "singlenode_dc", + "horizon": 8760, + "log_sha256": "1c36d558da588be6220369f8849d9eb0e3a1c3ba542b329d97acc58df6d7b764", + "maximum_residual": 2.2734142366568922e-12, + "peak_rss_bytes": { + "after_canonicalization": 13782138880, + "after_construction": 3723968512, + "after_extraction": 13782138880, + "after_solve": 13782138880 + }, + "phase_journal_sha256": "f2d7e25fb9956acb6d5d14e8416825fc484e4612b283bf3b01f121cdc06b040e", + "result_schema_sha256": "1cb86cd968061547876c643e2ed37f871e1b673dc4fee14e593fec1c2860498a", + "result_sha256": "c7cb2bdfd7fa8fbe6e0db9ea79f1c0b998ae34295eeeac1f96ee039bce4e8af1", + "returncode": 0, + "scientific_scalars": { + "objective": 1103303365.548844, + "storage_cost": 1.9450903842287586e-05 + }, + "serialized_result_bytes": 27911486, + "source_structure": { + "constraint_object_count": 70081, + "data_keys": [ + "Cg", + "Cload", + "Cs", + "Pd_series", + "Pgmax", + "Pgmin", + "T", + "baseMVA", + "ext_to_int", + "gen_bus", + "gencost", + "load_bus_external", + "load_bus_internal", + "load_device_ids", + "load_has_reactive", + "load_is_sheddable", + "load_max_shed_fraction", + "load_shedding_cost_per_mwh", + "nb", + "ng", + "nload", + "ns", + "nsheddable", + "sheddable_load_device_ids", + "sheddable_load_indices", + "source_nb", + "storage_aging_weight", + "storage_apparent_power_rating", + "storage_bus", + "storage_capacity", + "storage_delta", + "storage_device_id_is_explicit", + "storage_device_ids", + "storage_initial_soc", + "storage_terminal_constraint", + "storage_terminal_cost", + "storage_terminal_soc", + "storage_terminal_weight" + ], + "equality_object_count": 17521, + "expression_schema": [ + { + "name": "generator_cost", + "shapes": [ + [] + ] + }, + { + "name": "p_load", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "p_load_served", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "p_net", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ] + }, + { + "name": "q_load", + "shapes": [ + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ], + [ + 118 + ] + ] + }, + { + "name": "storage_cost", + "shapes": [ + [] + ] + } + ], + "formulation": "singlenode_dc", + "horizon": 8760, + "inequality_object_count": 52560, + "other_constraint_object_count": 0, + "parameter_object_count": 17520, + "parameter_schema": [ + { + "name": "load_inv_base_mva", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ] + }, + { + "name": "storage_inv_baseMVA", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ] + } + ], + "parameter_shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + "scalar_data": 4528923, + "scalar_equalities": 17521, + "scalar_inequalities": 981120, + "scalar_variables": 490560, + "temporal_assembly": "stepwise", + "variable_object_count": 26280, + "variable_schema": [ + { + "name": "Pg", + "shapes": [ + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ], + [ + 54 + ] + ] + }, + { + "name": "b", + "shapes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}, + { + "name": "soc", + "shapes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} + ] + }, + "source_structure_sha256": "538847f4b5267a6fe23a26e0e5ee915ffbabc11d0bab37548501f0bf4fe98dd9", + "timing_seconds": { + "canonicalization": 1397.4323467499926, + "construction": 108.60584949998884, + "extraction": 0.2918480840162374, + "solve_after_explicit_canonicalization": 12.256038166990038 + } + } + ], + "schema_version": 1, + "stage": "M14a_legacy_baseline" + }, + "case9": { + "accepted_as_ladder_record": true, + "analysis_context": { + "git_commit": "457ec9200050eae2a60dd470a131155a0ddaa53f", + "source_fingerprint": "f8c1768f3afd560171981c412202d6f10d4d42c5368a024070971504874cfbfd", + "worktree_clean": true + }, + "audit_tolerance": 1e-05, + "dirty_worker_points": [], + "execution_complete": true, + "execution_context": { + "git_commit": "1dd5e36dcae5ad9c8176b1d1202f1055acf95c03", + "machine": "arm64", + "packages": { + "clarabel": "0.11.1", + "cvxpy": "1.9.2", + "cyipopt": "1.7.0", + "ipopt": "3.14.19", + "numpy": "2.4.6", + "scipy": "1.17.1" + }, + "platform": "macOS-26.5.2-arm64-arm-64bit", + "python": "3.11.15", + "source_fingerprint": "02567a6928cede7d51d555affb84107e480a87adf748676f0e2ed2e598232e1b", + "worktree_clean": true + }, + "execution_provenance_clean": true, + "frozen_ladder": "case9", + "manifest": { + "bytes": 9029, + "sha256": "ba86631e7a6b1e9048d5f0e2a1d6ff99af92730d1a7ee70cd14c4df41d2fb944" + }, + "points": [ + { + "artifact_bytes": 9040, + "artifact_sha256": "a9234d90d7179ff4cc3c7b6364185b3e5283983df47f70f2b7966dc995de5fa3", + "audit_inputs_sha256": "07ddabdb060885c36869e52a9fb8540b2720f470873b7aa87b2bfe9120862210", + "canonical_structure": null, + "canonical_structure_sha256": "74234e98afe7498fb5daf1f36ac2d78acc339464f950703b8c019892f982b90b", + "case": "case9", + "classification": "completed", + "formulation": "ac", + "horizon": 1, + "log_sha256": "9f86dfcc7341773aa0eaecd34ba358bd0a94e73d1d4edd11abf856e06fba969d", + "maximum_residual": 3.552713678800501e-15, + "peak_rss_bytes": { + "after_canonicalization": null, + "after_construction": 146718720, + "after_extraction": 161595392, + "after_solve": 161595392 + }, + "phase_journal_sha256": "2e06de70afd4dd8e050e6868848bbdb0160116ce25a6321c3c0a2f28f3b1b6c6", + "result_schema_sha256": "d45b8803d3683b2b65a5821585a6519619ddbf9e4fa8b9eddaad73606d7251bf", + "result_sha256": "235919e4c67a50dbfed1636481e2bedd9403d2b1e837bda0eccd30332710068f", + "returncode": 0, + "scientific_scalars": { + "objective": 5296.629248038914, + "storage_cost": 1.7486812777779417e-17 + }, + "serialized_result_bytes": 2340, + "source_structure": { + "constraint_object_count": 90, + "data_keys": [ + "B", + "B_vec", + "Cg", + "Cload", + "Cs", + "E", + "G", + "G_vec", + "Pd_series", + "Pgmax", + "Pgmin", + "Qd_series", + "Qgmax", + "Qgmin", + "Rp", + "T", + "Ybus", + "Z", + "baseMVA", + "branch_from_bus_external", + "branch_from_bus_internal", + "branch_rate_a_mva", + "branch_status", + "branch_to_bus_external", + "branch_to_bus_internal", + "cols", + "constrained_branch_indices", + "ext_to_int", + "gen_bus", + "gencost", + "load_bus_external", + "load_bus_internal", + "load_device_ids", + "load_has_reactive", + "load_is_sheddable", + "load_max_shed_fraction", + "load_shedding_cost_per_mwh", + "nb", + "ng", + "nl", + "nload", + "ns", + "nsheddable", + "pv", + "ref", + "rows", + "sheddable_load_device_ids", + "sheddable_load_indices", + "storage_aging_weight", + "storage_apparent_power_rating", + "storage_bus", + "storage_capacity", + "storage_delta", + "storage_device_id_is_explicit", + "storage_device_ids", + "storage_initial_soc", + "storage_terminal_constraint", + "storage_terminal_cost", + "storage_terminal_soc", + "storage_terminal_weight" + ], + "equality_object_count": 65, + "expression_schema": [ + { + "name": "branch_p_from_pu", + "shapes": [ + [ + 9 + ] + ] + }, + { + "name": "branch_p_to_pu", + "shapes": [ + [ + 9 + ] + ] + }, + { + "name": "branch_q_from_pu", + "shapes": [ + [ + 9 + ] + ] + }, + { + "name": "branch_q_to_pu", + "shapes": [ + [ + 9 + ] + ] + }, + { + "name": "generator_cost", + "shapes": [ + [] + ] + }, + { + "name": "p_load", + "shapes": [ + [ + 9 + ] + ] + }, + { + "name": "p_load_served", + "shapes": [ + [ + 9 + ] + ] + }, + { + "name": "p_net", + "shapes": [ + [ + 9 + ] + ] + }, + { + "name": "q_load", + "shapes": [ + [ + 9 + ] + ] + }, + { + "name": "q_load_served", + "shapes": [ + [ + 9 + ] + ] + }, + { + "name": "q_net", + "shapes": [ + [ + 9 + ] + ] + }, + { + "name": "storage_cost", + "shapes": [ + [] + ] + } + ], + "formulation": "ac", + "horizon": 1, + "inequality_object_count": 25, + "other_constraint_object_count": 0, + "parameter_object_count": 2, + "parameter_schema": [ + { + "name": "load_inv_base_mva", + "shapes": [ + [] + ] + }, + { + "name": "storage_inv_baseMVA", + "shapes": [ + [] + ] + } + ], + "parameter_shapes": [ + [], + [] + ], + "scalar_data": 1042, + "scalar_equalities": 129, + "scalar_inequalities": 33, + "scalar_variables": 135, + "temporal_assembly": "stepwise", + "variable_object_count": 15, + "variable_schema": [ + { + "name": "P_vec", + "shapes": [ + [ + 27 + ] + ] + }, + { + "name": "Pg", + "shapes": [ + [ + 3 + ] + ] + }, + { + "name": "Q_vec", + "shapes": [ + [ + 27 + ] + ] + }, + { + "name": "Qg", + "shapes": [ + [ + 3 + ] + ] + }, + { + "name": "b", + "shapes": [ + [ + 1 + ] + ] + }, + { + "name": "b_q", + "shapes": [ + [ + 1 + ] + ] + }, + { + "name": "p", + "shapes": [ + [ + 9 + ] + ] + }, + { + "name": "q", + "shapes": [ + [ + 9 + ] + ] + }, + { + "name": "soc", + "shapes": [ + [ + 1 + ] + ] + }, + { + "name": "theta", + "shapes": [ + [ + 9, + 1 + ] + ] + }, + { + "name": "v", + "shapes": [ + [ + 9, + 1 + ] + ] + } + ] + }, + "source_structure_sha256": "7347c255db5392376fbd82868ec78a8165390dc2e36888ee43a8269654006dbb", + "timing_seconds": { + "canonicalization": null, + "construction": 0.014604417025111616, + "extraction": 8.174998220056295e-05, + "solve_after_explicit_canonicalization": 0.06237150001106784 + } + }, + { + "artifact_bytes": 11092, + "artifact_sha256": "d351e77145359da29848ef500aca819709438941f23b8242242cd41a53eb3520", + "audit_inputs_sha256": "07ddabdb060885c36869e52a9fb8540b2720f470873b7aa87b2bfe9120862210", + "canonical_structure": null, + "canonical_structure_sha256": "74234e98afe7498fb5daf1f36ac2d78acc339464f950703b8c019892f982b90b", + "case": "case9", + "classification": "completed", + "formulation": "ac", + "horizon": 2, + "log_sha256": "9f86dfcc7341773aa0eaecd34ba358bd0a94e73d1d4edd11abf856e06fba969d", + "maximum_residual": 1.4210854715202004e-14, + "peak_rss_bytes": { + "after_canonicalization": null, + "after_construction": 148045824, + "after_extraction": 180715520, + "after_solve": 180715520 + }, + "phase_journal_sha256": "109f7066ac8059a549c0dc6e5805c9101612104d350c171e4a07db9904a6a14f", + "result_schema_sha256": "95df1da0ca597f6a8c509c72dce458fd7c22bcea1b462f5bf67bb50efe093099", + "result_sha256": "8a2918c56c661c726660bd98c58326f01f273d52b52ff0b2d03afbbbd5de0e82", + "returncode": 0, + "scientific_scalars": { + "objective": 10593.258496096834, + "storage_cost": 4.391975560124538e-17 + }, + "serialized_result_bytes": 4252, + "source_structure": { + "constraint_object_count": 179, + "data_keys": [ + "B", + "B_vec", + "Cg", + "Cload", + "Cs", + "E", + "G", + "G_vec", + "Pd_series", + "Pgmax", + "Pgmin", + "Qd_series", + "Qgmax", + "Qgmin", + "Rp", + "T", + "Ybus", + "Z", + "baseMVA", + "branch_from_bus_external", + "branch_from_bus_internal", + "branch_rate_a_mva", + "branch_status", + "branch_to_bus_external", + "branch_to_bus_internal", + "cols", + "constrained_branch_indices", + "ext_to_int", + "gen_bus", + "gencost", + "load_bus_external", + "load_bus_internal", + "load_device_ids", + "load_has_reactive", + "load_is_sheddable", + "load_max_shed_fraction", + "load_shedding_cost_per_mwh", + "nb", + "ng", + "nl", + "nload", + "ns", + "nsheddable", + "pv", + "ref", + "rows", + "sheddable_load_device_ids", + "sheddable_load_indices", + "storage_aging_weight", + "storage_apparent_power_rating", + "storage_bus", + "storage_capacity", + "storage_delta", + "storage_device_id_is_explicit", + "storage_device_ids", + "storage_initial_soc", + "storage_terminal_constraint", + "storage_terminal_cost", + "storage_terminal_soc", + "storage_terminal_weight" + ], + "equality_object_count": 129, + "expression_schema": [ + { + "name": "branch_p_from_pu", + "shapes": [ + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "branch_p_to_pu", + "shapes": [ + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "branch_q_from_pu", + "shapes": [ + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "branch_q_to_pu", + "shapes": [ + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "generator_cost", + "shapes": [ + [] + ] + }, + { + "name": "p_load", + "shapes": [ + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "p_load_served", + "shapes": [ + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "p_net", + "shapes": [ + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "q_load", + "shapes": [ + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "q_load_served", + "shapes": [ + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "q_net", + "shapes": [ + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "storage_cost", + "shapes": [ + [] + ] + } + ], + "formulation": "ac", + "horizon": 2, + "inequality_object_count": 50, + "other_constraint_object_count": 0, + "parameter_object_count": 4, + "parameter_schema": [ + { + "name": "load_inv_base_mva", + "shapes": [ + [], + [] + ] + }, + { + "name": "storage_inv_baseMVA", + "shapes": [ + [], + [] + ] + } + ], + "parameter_shapes": [ + [], + [], + [], + [] + ], + "scalar_data": 2081, + "scalar_equalities": 257, + "scalar_inequalities": 66, + "scalar_variables": 270, + "temporal_assembly": "stepwise", + "variable_object_count": 30, + "variable_schema": [ + { + "name": "P_vec", + "shapes": [ + [ + 27 + ], + [ + 27 + ] + ] + }, + { + "name": "Pg", + "shapes": [ + [ + 3 + ], + [ + 3 + ] + ] + }, + { + "name": "Q_vec", + "shapes": [ + [ + 27 + ], + [ + 27 + ] + ] + }, + { + "name": "Qg", + "shapes": [ + [ + 3 + ], + [ + 3 + ] + ] + }, + { + "name": "b", + "shapes": [ + [ + 1 + ], + [ + 1 + ] + ] + }, + { + "name": "b_q", + "shapes": [ + [ + 1 + ], + [ + 1 + ] + ] + }, + { + "name": "p", + "shapes": [ + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "q", + "shapes": [ + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "soc", + "shapes": [ + [ + 1 + ], + [ + 1 + ] + ] + }, + { + "name": "theta", + "shapes": [ + [ + 9, + 1 + ], + [ + 9, + 1 + ] + ] + }, + { + "name": "v", + "shapes": [ + [ + 9, + 1 + ], + [ + 9, + 1 + ] + ] + } + ] + }, + "source_structure_sha256": "9b590529b870635d4e19b6936aff178fa40a36655ac2113b660d1afac61680cb", + "timing_seconds": { + "canonicalization": null, + "construction": 0.02340725000249222, + "extraction": 8.970795897766948e-05, + "solve_after_explicit_canonicalization": 0.13198820897378027 + } + }, + { + "artifact_bytes": 15060, + "artifact_sha256": "99fb8050a06cd3881eb3de982a6a18232b7234f16d73784d9ac17db88e201461", + "audit_inputs_sha256": "07ddabdb060885c36869e52a9fb8540b2720f470873b7aa87b2bfe9120862210", + "canonical_structure": null, + "canonical_structure_sha256": "74234e98afe7498fb5daf1f36ac2d78acc339464f950703b8c019892f982b90b", + "case": "case9", + "classification": "completed", + "formulation": "ac", + "horizon": 4, + "log_sha256": "9f86dfcc7341773aa0eaecd34ba358bd0a94e73d1d4edd11abf856e06fba969d", + "maximum_residual": 3.552713678800501e-15, + "peak_rss_bytes": { + "after_canonicalization": null, + "after_construction": 149831680, + "after_extraction": 236306432, + "after_solve": 236306432 + }, + "phase_journal_sha256": "b558b101b71c3433e2c1edaa51b7a0dbca361a4f7e30de1413390fa5b9df3444", + "result_schema_sha256": "c1253f07f124f237f4164e4fae598acd587a6833cd81185604b3cfec599e7fd5", + "result_sha256": "88b3c093079cdc776d4b0e681fc391c005d7598bb733d5d67c56ae28a4a31216", + "returncode": 0, + "scientific_scalars": { + "objective": 21186.516991551714, + "storage_cost": 7.683744979415929e-17 + }, + "serialized_result_bytes": 8051, + "source_structure": { + "constraint_object_count": 357, + "data_keys": [ + "B", + "B_vec", + "Cg", + "Cload", + "Cs", + "E", + "G", + "G_vec", + "Pd_series", + "Pgmax", + "Pgmin", + "Qd_series", + "Qgmax", + "Qgmin", + "Rp", + "T", + "Ybus", + "Z", + "baseMVA", + "branch_from_bus_external", + "branch_from_bus_internal", + "branch_rate_a_mva", + "branch_status", + "branch_to_bus_external", + "branch_to_bus_internal", + "cols", + "constrained_branch_indices", + "ext_to_int", + "gen_bus", + "gencost", + "load_bus_external", + "load_bus_internal", + "load_device_ids", + "load_has_reactive", + "load_is_sheddable", + "load_max_shed_fraction", + "load_shedding_cost_per_mwh", + "nb", + "ng", + "nl", + "nload", + "ns", + "nsheddable", + "pv", + "ref", + "rows", + "sheddable_load_device_ids", + "sheddable_load_indices", + "storage_aging_weight", + "storage_apparent_power_rating", + "storage_bus", + "storage_capacity", + "storage_delta", + "storage_device_id_is_explicit", + "storage_device_ids", + "storage_initial_soc", + "storage_terminal_constraint", + "storage_terminal_cost", + "storage_terminal_soc", + "storage_terminal_weight" + ], + "equality_object_count": 257, + "expression_schema": [ + { + "name": "branch_p_from_pu", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "branch_p_to_pu", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "branch_q_from_pu", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "branch_q_to_pu", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "generator_cost", + "shapes": [ + [] + ] + }, + { + "name": "p_load", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "p_load_served", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "p_net", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "q_load", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "q_load_served", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "q_net", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "storage_cost", + "shapes": [ + [] + ] + } + ], + "formulation": "ac", + "horizon": 4, + "inequality_object_count": 100, + "other_constraint_object_count": 0, + "parameter_object_count": 8, + "parameter_schema": [ + { + "name": "load_inv_base_mva", + "shapes": [ + [], + [], + [], + [] + ] + }, + { + "name": "storage_inv_baseMVA", + "shapes": [ + [], + [], + [], + [] + ] + } + ], + "parameter_shapes": [ + [], + [], + [], + [], + [], + [], + [], + [] + ], + "scalar_data": 4159, + "scalar_equalities": 513, + "scalar_inequalities": 132, + "scalar_variables": 540, + "temporal_assembly": "stepwise", + "variable_object_count": 60, + "variable_schema": [ + { + "name": "P_vec", + "shapes": [ + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ] + ] + }, + { + "name": "Pg", + "shapes": [ + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ] + ] + }, + { + "name": "Q_vec", + "shapes": [ + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ] + ] + }, + { + "name": "Qg", + "shapes": [ + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ] + ] + }, + { + "name": "b", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + }, + { + "name": "b_q", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + }, + { + "name": "p", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "q", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "soc", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + }, + { + "name": "theta", + "shapes": [ + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ] + ] + }, + { + "name": "v", + "shapes": [ + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ] + ] + } + ] + }, + "source_structure_sha256": "24894356e0dbe7a52c6d11ded4ecb16f44da560f37c5f2d2468133b4fe39f05e", + "timing_seconds": { + "canonicalization": null, + "construction": 0.044954916986171156, + "extraction": 0.0001188750029541552, + "solve_after_explicit_canonicalization": 0.2683907499886118 + } + }, + { + "artifact_bytes": 23040, + "artifact_sha256": "4af97dd60206bc3592b501b7714eeba1d7a744b5ea6410df1416134b9ec2250b", + "audit_inputs_sha256": "07ddabdb060885c36869e52a9fb8540b2720f470873b7aa87b2bfe9120862210", + "canonical_structure": null, + "canonical_structure_sha256": "74234e98afe7498fb5daf1f36ac2d78acc339464f950703b8c019892f982b90b", + "case": "case9", + "classification": "completed", + "formulation": "ac", + "horizon": 8, + "log_sha256": "9f86dfcc7341773aa0eaecd34ba358bd0a94e73d1d4edd11abf856e06fba969d", + "maximum_residual": 7.105427357601002e-15, + "peak_rss_bytes": { + "after_canonicalization": null, + "after_construction": 154714112, + "after_extraction": 415481856, + "after_solve": 415481856 + }, + "phase_journal_sha256": "41e0ddc8da91b432df88e9f5bf65fa98545dea12bdd9936e4ec537d1723d5254", + "result_schema_sha256": "a44da5dc55f70bd10718871f65e22c849c5b3423de13f4d66ec848a2c500384e", + "result_sha256": "6a232adb3ce48c015c0a1996d4cd01cacdb224a2ea431242c37cad7c997bac76", + "returncode": 0, + "scientific_scalars": { + "objective": 42373.03398291083, + "storage_cost": 5.471907060563339e-17 + }, + "serialized_result_bytes": 15619, + "source_structure": { + "constraint_object_count": 713, + "data_keys": [ + "B", + "B_vec", + "Cg", + "Cload", + "Cs", + "E", + "G", + "G_vec", + "Pd_series", + "Pgmax", + "Pgmin", + "Qd_series", + "Qgmax", + "Qgmin", + "Rp", + "T", + "Ybus", + "Z", + "baseMVA", + "branch_from_bus_external", + "branch_from_bus_internal", + "branch_rate_a_mva", + "branch_status", + "branch_to_bus_external", + "branch_to_bus_internal", + "cols", + "constrained_branch_indices", + "ext_to_int", + "gen_bus", + "gencost", + "load_bus_external", + "load_bus_internal", + "load_device_ids", + "load_has_reactive", + "load_is_sheddable", + "load_max_shed_fraction", + "load_shedding_cost_per_mwh", + "nb", + "ng", + "nl", + "nload", + "ns", + "nsheddable", + "pv", + "ref", + "rows", + "sheddable_load_device_ids", + "sheddable_load_indices", + "storage_aging_weight", + "storage_apparent_power_rating", + "storage_bus", + "storage_capacity", + "storage_delta", + "storage_device_id_is_explicit", + "storage_device_ids", + "storage_initial_soc", + "storage_terminal_constraint", + "storage_terminal_cost", + "storage_terminal_soc", + "storage_terminal_weight" + ], + "equality_object_count": 513, + "expression_schema": [ + { + "name": "branch_p_from_pu", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "branch_p_to_pu", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "branch_q_from_pu", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "branch_q_to_pu", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "generator_cost", + "shapes": [ + [] + ] + }, + { + "name": "p_load", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "p_load_served", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "p_net", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "q_load", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "q_load_served", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "q_net", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "storage_cost", + "shapes": [ + [] + ] + } + ], + "formulation": "ac", + "horizon": 8, + "inequality_object_count": 200, + "other_constraint_object_count": 0, + "parameter_object_count": 16, + "parameter_schema": [ + { + "name": "load_inv_base_mva", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [] + ] + }, + { + "name": "storage_inv_baseMVA", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [] + ] + } + ], + "parameter_shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + "scalar_data": 8315, + "scalar_equalities": 1025, + "scalar_inequalities": 264, + "scalar_variables": 1080, + "temporal_assembly": "stepwise", + "variable_object_count": 120, + "variable_schema": [ + { + "name": "P_vec", + "shapes": [ + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ] + ] + }, + { + "name": "Pg", + "shapes": [ + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ] + ] + }, + { + "name": "Q_vec", + "shapes": [ + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ] + ] + }, + { + "name": "Qg", + "shapes": [ + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ] + ] + }, + { + "name": "b", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + }, + { + "name": "b_q", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + }, + { + "name": "p", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "q", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "soc", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + }, + { + "name": "theta", + "shapes": [ + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ] + ] + }, + { + "name": "v", + "shapes": [ + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ] + ] + } + ] + }, + "source_structure_sha256": "d2ba5485169db2cb06077e210c9941258aecc5184c65a674b619ac124d3a391d", + "timing_seconds": { + "canonicalization": null, + "construction": 0.11076908395625651, + "extraction": 0.0002894580247811973, + "solve_after_explicit_canonicalization": 0.9045450830017217 + } + }, + { + "artifact_bytes": 55204, + "artifact_sha256": "960135671ee524150dacf7547426a93e787158a9b7816542388f77a29119eaba", + "audit_inputs_sha256": "07ddabdb060885c36869e52a9fb8540b2720f470873b7aa87b2bfe9120862210", + "canonical_structure": null, + "canonical_structure_sha256": "74234e98afe7498fb5daf1f36ac2d78acc339464f950703b8c019892f982b90b", + "case": "case9", + "classification": "completed", + "formulation": "ac", + "horizon": 24, + "log_sha256": "9f86dfcc7341773aa0eaecd34ba358bd0a94e73d1d4edd11abf856e06fba969d", + "maximum_residual": 1.4210854715202004e-14, + "peak_rss_bytes": { + "after_canonicalization": null, + "after_construction": 172621824, + "after_extraction": 2369929216, + "after_solve": 2369929216 + }, + "phase_journal_sha256": "1aaee3753904fbaab3980bb7b38ffc60006e0a69ff6e2767cbcb8f38f9e6ba1d", + "result_schema_sha256": "1b692325a458ba250466f3a617625534d21cb07ce5fc4aa8e8bd27c0d572364c", + "result_sha256": "cf692c3f4b01b15c888d94e138ffaeb4dd13dd93f7017e23b9cde5d713d8c5de", + "returncode": 0, + "scientific_scalars": { + "objective": 127119.10194974828, + "storage_cost": 1.7643756833929494e-16 + }, + "serialized_result_bytes": 46089, + "source_structure": { + "constraint_object_count": 2137, + "data_keys": [ + "B", + "B_vec", + "Cg", + "Cload", + "Cs", + "E", + "G", + "G_vec", + "Pd_series", + "Pgmax", + "Pgmin", + "Qd_series", + "Qgmax", + "Qgmin", + "Rp", + "T", + "Ybus", + "Z", + "baseMVA", + "branch_from_bus_external", + "branch_from_bus_internal", + "branch_rate_a_mva", + "branch_status", + "branch_to_bus_external", + "branch_to_bus_internal", + "cols", + "constrained_branch_indices", + "ext_to_int", + "gen_bus", + "gencost", + "load_bus_external", + "load_bus_internal", + "load_device_ids", + "load_has_reactive", + "load_is_sheddable", + "load_max_shed_fraction", + "load_shedding_cost_per_mwh", + "nb", + "ng", + "nl", + "nload", + "ns", + "nsheddable", + "pv", + "ref", + "rows", + "sheddable_load_device_ids", + "sheddable_load_indices", + "storage_aging_weight", + "storage_apparent_power_rating", + "storage_bus", + "storage_capacity", + "storage_delta", + "storage_device_id_is_explicit", + "storage_device_ids", + "storage_initial_soc", + "storage_terminal_constraint", + "storage_terminal_cost", + "storage_terminal_soc", + "storage_terminal_weight" + ], + "equality_object_count": 1537, + "expression_schema": [ + { + "name": "branch_p_from_pu", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "branch_p_to_pu", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "branch_q_from_pu", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "branch_q_to_pu", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "generator_cost", + "shapes": [ + [] + ] + }, + { + "name": "p_load", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "p_load_served", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "p_net", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "q_load", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "q_load_served", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "q_net", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "storage_cost", + "shapes": [ + [] + ] + } + ], + "formulation": "ac", + "horizon": 24, + "inequality_object_count": 600, + "other_constraint_object_count": 0, + "parameter_object_count": 48, + "parameter_schema": [ + { + "name": "load_inv_base_mva", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ] + }, + { + "name": "storage_inv_baseMVA", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ] + } + ], + "parameter_shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + "scalar_data": 24939, + "scalar_equalities": 3073, + "scalar_inequalities": 792, + "scalar_variables": 3240, + "temporal_assembly": "stepwise", + "variable_object_count": 360, + "variable_schema": [ + { + "name": "P_vec", + "shapes": [ + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ] + ] + }, + { + "name": "Pg", + "shapes": [ + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ] + ] + }, + { + "name": "Q_vec", + "shapes": [ + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ], + [ + 27 + ] + ] + }, + { + "name": "Qg", + "shapes": [ + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ] + ] + }, + { + "name": "b", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + }, + { + "name": "b_q", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + }, + { + "name": "p", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "q", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "soc", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + }, + { + "name": "theta", + "shapes": [ + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ] + ] + }, + { + "name": "v", + "shapes": [ + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ], + [ + 9, + 1 + ] + ] + } + ] + }, + "source_structure_sha256": "ed946e8b271e9c14c2e8bb63368dcc2a0513e7c3a812aa403594935a9d8cd5b8", + "timing_seconds": { + "canonicalization": null, + "construction": 0.3351249999832362, + "extraction": 0.00036270800046622753, + "solve_after_explicit_canonicalization": 3.265759458008688 + } + }, + { + "artifact_bytes": 6200, + "artifact_sha256": "31a45d5b747268d9e2315df5140821ecff5eb30494c44ce57dbe28a63b01952f", + "audit_inputs_sha256": "568af6c3cb77d57e6c1d64f6fab3a2a719c91c3d755dfc4aa407055161e6eeec", + "canonical_structure": { + "backend": "CPP", + "canonical_variable_count": 27, + "coefficient_columns": 27, + "coefficient_nonzeros": 90, + "coefficient_rows": 53, + "equality_rows": 14, + "exponential_cones": 0, + "formulation": "lossy_dc", + "nonnegative_rows": 39, + "positive_semidefinite_cones": [], + "power_cones_3d": [], + "quadratic_nonzeros": 9, + "reduction_chain": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "second_order_cones": [], + "solver": "CLARABEL", + "temporal_assembly": "stepwise" + }, + "canonical_structure_sha256": "314299e58db2db20a9a6762e139ddcebb1cf1ce5674e69e5ff6545529e3e1108", + "case": "case9", + "classification": "completed", + "formulation": "lossy_dc", + "horizon": 1, + "log_sha256": "9f86dfcc7341773aa0eaecd34ba358bd0a94e73d1d4edd11abf856e06fba969d", + "maximum_residual": 7.105427357601002e-15, + "peak_rss_bytes": { + "after_canonicalization": 147062784, + "after_construction": 145375232, + "after_extraction": 147570688, + "after_solve": 147570688 + }, + "phase_journal_sha256": "0b3145260f7ef08932fc204eab667daa62e759f359ea1a135c27395fc58c5c2e", + "result_schema_sha256": "95cdcbded1cbd491d0dbd48258962fa319c8afd64e6da5b838b4b6aa4616a966", + "result_sha256": "90674a35b3669791b519374feb92bbfad20e2050174c2f56ec3b6a6e6d49ffb8", + "returncode": 0, + "scientific_scalars": { + "objective": 5216.065330454343, + "storage_cost": 4.801681441025089e-17 + }, + "serialized_result_bytes": 754, + "source_structure": { + "constraint_object_count": 10, + "data_keys": [ + "A", + "Cg", + "Cload", + "Cs", + "Pd_series", + "Pgmax", + "Pgmin", + "T", + "baseMVA", + "ext_to_int", + "f_max", + "gen_bus", + "gencost", + "load_bus_external", + "load_bus_internal", + "load_device_ids", + "load_has_reactive", + "load_is_sheddable", + "load_max_shed_fraction", + "load_shedding_cost_per_mwh", + "loss_weight", + "nb", + "ng", + "nl", + "nload", + "ns", + "nsheddable", + "r", + "sheddable_load_device_ids", + "sheddable_load_indices", + "storage_aging_weight", + "storage_apparent_power_rating", + "storage_bus", + "storage_capacity", + "storage_delta", + "storage_device_id_is_explicit", + "storage_device_ids", + "storage_initial_soc", + "storage_terminal_constraint", + "storage_terminal_cost", + "storage_terminal_soc", + "storage_terminal_weight" + ], + "equality_object_count": 3, + "expression_schema": [ + { + "name": "dc_loss_cost", + "shapes": [ + [] + ] + }, + { + "name": "generator_cost", + "shapes": [ + [] + ] + }, + { + "name": "p_load", + "shapes": [ + [ + 9 + ] + ] + }, + { + "name": "p_load_served", + "shapes": [ + [ + 9 + ] + ] + }, + { + "name": "p_net", + "shapes": [ + [ + 9 + ] + ] + }, + { + "name": "q_load", + "shapes": [ + [ + 9 + ] + ] + }, + { + "name": "storage_cost", + "shapes": [ + [] + ] + } + ], + "formulation": "lossy_dc", + "horizon": 1, + "inequality_object_count": 7, + "other_constraint_object_count": 0, + "parameter_object_count": 2, + "parameter_schema": [ + { + "name": "load_inv_base_mva", + "shapes": [ + [] + ] + }, + { + "name": "storage_inv_baseMVA", + "shapes": [ + [] + ] + } + ], + "parameter_shapes": [ + [], + [] + ], + "scalar_data": 254, + "scalar_equalities": 11, + "scalar_inequalities": 19, + "scalar_variables": 14, + "temporal_assembly": "stepwise", + "variable_object_count": 4, + "variable_schema": [ + { + "name": "Pg", + "shapes": [ + [ + 3 + ] + ] + }, + { + "name": "b", + "shapes": [ + [ + 1 + ] + ] + }, + { + "name": "p_flows", + "shapes": [ + [ + 9 + ] + ] + }, + { + "name": "soc", + "shapes": [ + [ + 1 + ] + ] + } + ] + }, + "source_structure_sha256": "99f90dea9e306cc1b0ed336fd6a54f81181d8cf0208826f0a48746ea2c7fccbf", + "timing_seconds": { + "canonicalization": 0.007016042014583945, + "construction": 0.003874707967042923, + "extraction": 6.479199510067701e-05, + "solve_after_explicit_canonicalization": 0.0007423339993692935 + } + }, + { + "artifact_bytes": 6820, + "artifact_sha256": "7e60b1c75c06242c5f7383cecfd5baf88f7bd376f3750447fe6473f70b881cc2", + "audit_inputs_sha256": "568af6c3cb77d57e6c1d64f6fab3a2a719c91c3d755dfc4aa407055161e6eeec", + "canonical_structure": { + "backend": "CPP", + "canonical_variable_count": 54, + "coefficient_columns": 54, + "coefficient_nonzeros": 180, + "coefficient_rows": 105, + "equality_rows": 27, + "exponential_cones": 0, + "formulation": "lossy_dc", + "nonnegative_rows": 78, + "positive_semidefinite_cones": [], + "power_cones_3d": [], + "quadratic_nonzeros": 18, + "reduction_chain": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "second_order_cones": [], + "solver": "CLARABEL", + "temporal_assembly": "stepwise" + }, + "canonical_structure_sha256": "f00883db230b020e7720b3289e383c92507eac4e6e8f2cf070d2780f983d5807", + "case": "case9", + "classification": "completed", + "formulation": "lossy_dc", + "horizon": 2, + "log_sha256": "9f86dfcc7341773aa0eaecd34ba358bd0a94e73d1d4edd11abf856e06fba969d", + "maximum_residual": 7.105427357601002e-15, + "peak_rss_bytes": { + "after_canonicalization": 147783680, + "after_construction": 145571840, + "after_extraction": 148307968, + "after_solve": 148307968 + }, + "phase_journal_sha256": "590140894cdc8c4aa8666ffc3c83bb254b11779489a529f62456fb2ac32db37b", + "result_schema_sha256": "68b9db7c84a45791839fee7810cad1a2cc1a93a55b2c92f3fa75cfb0be01d1f4", + "result_sha256": "f662a0a9bf78a87df19d2a08fd4e30ffa1e89438f2a7c7059b7b8c84b760c25c", + "returncode": 0, + "scientific_scalars": { + "objective": 10432.130660908686, + "storage_cost": 1.6398180317967452e-16 + }, + "serialized_result_bytes": 1307, + "source_structure": { + "constraint_object_count": 19, + "data_keys": [ + "A", + "Cg", + "Cload", + "Cs", + "Pd_series", + "Pgmax", + "Pgmin", + "T", + "baseMVA", + "ext_to_int", + "f_max", + "gen_bus", + "gencost", + "load_bus_external", + "load_bus_internal", + "load_device_ids", + "load_has_reactive", + "load_is_sheddable", + "load_max_shed_fraction", + "load_shedding_cost_per_mwh", + "loss_weight", + "nb", + "ng", + "nl", + "nload", + "ns", + "nsheddable", + "r", + "sheddable_load_device_ids", + "sheddable_load_indices", + "storage_aging_weight", + "storage_apparent_power_rating", + "storage_bus", + "storage_capacity", + "storage_delta", + "storage_device_id_is_explicit", + "storage_device_ids", + "storage_initial_soc", + "storage_terminal_constraint", + "storage_terminal_cost", + "storage_terminal_soc", + "storage_terminal_weight" + ], + "equality_object_count": 5, + "expression_schema": [ + { + "name": "dc_loss_cost", + "shapes": [ + [] + ] + }, + { + "name": "generator_cost", + "shapes": [ + [] + ] + }, + { + "name": "p_load", + "shapes": [ + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "p_load_served", + "shapes": [ + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "p_net", + "shapes": [ + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "q_load", + "shapes": [ + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "storage_cost", + "shapes": [ + [] + ] + } + ], + "formulation": "lossy_dc", + "horizon": 2, + "inequality_object_count": 14, + "other_constraint_object_count": 0, + "parameter_object_count": 4, + "parameter_schema": [ + { + "name": "load_inv_base_mva", + "shapes": [ + [], + [] + ] + }, + { + "name": "storage_inv_baseMVA", + "shapes": [ + [], + [] + ] + } + ], + "parameter_shapes": [ + [], + [], + [], + [] + ], + "scalar_data": 505, + "scalar_equalities": 21, + "scalar_inequalities": 38, + "scalar_variables": 28, + "temporal_assembly": "stepwise", + "variable_object_count": 8, + "variable_schema": [ + { + "name": "Pg", + "shapes": [ + [ + 3 + ], + [ + 3 + ] + ] + }, + { + "name": "b", + "shapes": [ + [ + 1 + ], + [ + 1 + ] + ] + }, + { + "name": "p_flows", + "shapes": [ + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "soc", + "shapes": [ + [ + 1 + ], + [ + 1 + ] + ] + } + ] + }, + "source_structure_sha256": "1abbb7135225ab1046c99afab9f185b4a6c244bd3bb4c28df0f9255f05039b5d", + "timing_seconds": { + "canonicalization": 0.010298125038389117, + "construction": 0.004796791996341199, + "extraction": 9.300000965595245e-05, + "solve_after_explicit_canonicalization": 0.0009854580275714397 + } + }, + { + "artifact_bytes": 7919, + "artifact_sha256": "2083531a74271dc84ceddf517b77ab4a9d2c37c0332e23e11e4d1206c80ff43d", + "audit_inputs_sha256": "568af6c3cb77d57e6c1d64f6fab3a2a719c91c3d755dfc4aa407055161e6eeec", + "canonical_structure": { + "backend": "CPP", + "canonical_variable_count": 108, + "coefficient_columns": 108, + "coefficient_nonzeros": 360, + "coefficient_rows": 209, + "equality_rows": 53, + "exponential_cones": 0, + "formulation": "lossy_dc", + "nonnegative_rows": 156, + "positive_semidefinite_cones": [], + "power_cones_3d": [], + "quadratic_nonzeros": 36, + "reduction_chain": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "second_order_cones": [], + "solver": "CLARABEL", + "temporal_assembly": "stepwise" + }, + "canonical_structure_sha256": "7acaaf407ea5c63ce2944f0e3d1d190115507e1501b839df349c316fa52ad790", + "case": "case9", + "classification": "completed", + "formulation": "lossy_dc", + "horizon": 4, + "log_sha256": "9f86dfcc7341773aa0eaecd34ba358bd0a94e73d1d4edd11abf856e06fba969d", + "maximum_residual": 1.4210854715202004e-14, + "peak_rss_bytes": { + "after_canonicalization": 148815872, + "after_construction": 145817600, + "after_extraction": 149389312, + "after_solve": 149389312 + }, + "phase_journal_sha256": "c244f0abbcace818bc61f463e5257515083553b87f1ad9e5fcd2af7fb79b0b7c", + "result_schema_sha256": "c9acdfbab57ed3c31edaa330594d147ee96f1ba32f151dd648bcd7075987d537", + "result_sha256": "a6fa9f5fcaf9a965dd4b7822ee91bc0e494e7e16ffc0af2a3ec5863393a39969", + "returncode": 0, + "scientific_scalars": { + "objective": 20864.261321817372, + "storage_cost": 2.1677740405703387e-15 + }, + "serialized_result_bytes": 2293, + "source_structure": { + "constraint_object_count": 37, + "data_keys": [ + "A", + "Cg", + "Cload", + "Cs", + "Pd_series", + "Pgmax", + "Pgmin", + "T", + "baseMVA", + "ext_to_int", + "f_max", + "gen_bus", + "gencost", + "load_bus_external", + "load_bus_internal", + "load_device_ids", + "load_has_reactive", + "load_is_sheddable", + "load_max_shed_fraction", + "load_shedding_cost_per_mwh", + "loss_weight", + "nb", + "ng", + "nl", + "nload", + "ns", + "nsheddable", + "r", + "sheddable_load_device_ids", + "sheddable_load_indices", + "storage_aging_weight", + "storage_apparent_power_rating", + "storage_bus", + "storage_capacity", + "storage_delta", + "storage_device_id_is_explicit", + "storage_device_ids", + "storage_initial_soc", + "storage_terminal_constraint", + "storage_terminal_cost", + "storage_terminal_soc", + "storage_terminal_weight" + ], + "equality_object_count": 9, + "expression_schema": [ + { + "name": "dc_loss_cost", + "shapes": [ + [] + ] + }, + { + "name": "generator_cost", + "shapes": [ + [] + ] + }, + { + "name": "p_load", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "p_load_served", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "p_net", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "q_load", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "storage_cost", + "shapes": [ + [] + ] + } + ], + "formulation": "lossy_dc", + "horizon": 4, + "inequality_object_count": 28, + "other_constraint_object_count": 0, + "parameter_object_count": 8, + "parameter_schema": [ + { + "name": "load_inv_base_mva", + "shapes": [ + [], + [], + [], + [] + ] + }, + { + "name": "storage_inv_baseMVA", + "shapes": [ + [], + [], + [], + [] + ] + } + ], + "parameter_shapes": [ + [], + [], + [], + [], + [], + [], + [], + [] + ], + "scalar_data": 1007, + "scalar_equalities": 41, + "scalar_inequalities": 76, + "scalar_variables": 56, + "temporal_assembly": "stepwise", + "variable_object_count": 16, + "variable_schema": [ + { + "name": "Pg", + "shapes": [ + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ] + ] + }, + { + "name": "b", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + }, + { + "name": "p_flows", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "soc", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + } + ] + }, + "source_structure_sha256": "9cf27b551713473011f1c2725fb7b6865ec44da1cbde2748aee8875d7b057857", + "timing_seconds": { + "canonicalization": 0.016762792016379535, + "construction": 0.006699041987303644, + "extraction": 0.00013649999164044857, + "solve_after_explicit_canonicalization": 0.0013732080115005374 + } + }, + { + "artifact_bytes": 9924, + "artifact_sha256": "a717dcec6647bda2460875cb4e9606e02c6cfd9953fff3f51d8855c389f734da", + "audit_inputs_sha256": "568af6c3cb77d57e6c1d64f6fab3a2a719c91c3d755dfc4aa407055161e6eeec", + "canonical_structure": { + "backend": "CPP", + "canonical_variable_count": 216, + "coefficient_columns": 216, + "coefficient_nonzeros": 720, + "coefficient_rows": 417, + "equality_rows": 105, + "exponential_cones": 0, + "formulation": "lossy_dc", + "nonnegative_rows": 312, + "positive_semidefinite_cones": [], + "power_cones_3d": [], + "quadratic_nonzeros": 72, + "reduction_chain": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "second_order_cones": [], + "solver": "CLARABEL", + "temporal_assembly": "stepwise" + }, + "canonical_structure_sha256": "fc2e9c55706b8b5797bc74c8dfa8f77207764c8a2d8f018cfe669d5cd0b46faf", + "case": "case9", + "classification": "completed", + "formulation": "lossy_dc", + "horizon": 8, + "log_sha256": "9f86dfcc7341773aa0eaecd34ba358bd0a94e73d1d4edd11abf856e06fba969d", + "maximum_residual": 1.4210854715202004e-14, + "peak_rss_bytes": { + "after_canonicalization": 150601728, + "after_construction": 145801216, + "after_extraction": 151289856, + "after_solve": 151289856 + }, + "phase_journal_sha256": "255aaa956682e55bb66e7eb0712c4fb1e3acd50b06f1f98be4aea5a40d8ca641", + "result_schema_sha256": "3facd99b21bf2638ad1bf1dc44dba02c6d80988a8f6416e7324c7b11a15403e8", + "result_sha256": "f7afa95e12c71d30889c05565ba844b84c9b4338dd14238097ac27b8b460aa65", + "returncode": 0, + "scientific_scalars": { + "objective": 41728.52264363474, + "storage_cost": 1.9934107113368103e-16 + }, + "serialized_result_bytes": 4155, + "source_structure": { + "constraint_object_count": 73, + "data_keys": [ + "A", + "Cg", + "Cload", + "Cs", + "Pd_series", + "Pgmax", + "Pgmin", + "T", + "baseMVA", + "ext_to_int", + "f_max", + "gen_bus", + "gencost", + "load_bus_external", + "load_bus_internal", + "load_device_ids", + "load_has_reactive", + "load_is_sheddable", + "load_max_shed_fraction", + "load_shedding_cost_per_mwh", + "loss_weight", + "nb", + "ng", + "nl", + "nload", + "ns", + "nsheddable", + "r", + "sheddable_load_device_ids", + "sheddable_load_indices", + "storage_aging_weight", + "storage_apparent_power_rating", + "storage_bus", + "storage_capacity", + "storage_delta", + "storage_device_id_is_explicit", + "storage_device_ids", + "storage_initial_soc", + "storage_terminal_constraint", + "storage_terminal_cost", + "storage_terminal_soc", + "storage_terminal_weight" + ], + "equality_object_count": 17, + "expression_schema": [ + { + "name": "dc_loss_cost", + "shapes": [ + [] + ] + }, + { + "name": "generator_cost", + "shapes": [ + [] + ] + }, + { + "name": "p_load", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "p_load_served", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "p_net", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "q_load", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "storage_cost", + "shapes": [ + [] + ] + } + ], + "formulation": "lossy_dc", + "horizon": 8, + "inequality_object_count": 56, + "other_constraint_object_count": 0, + "parameter_object_count": 16, + "parameter_schema": [ + { + "name": "load_inv_base_mva", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [] + ] + }, + { + "name": "storage_inv_baseMVA", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [] + ] + } + ], + "parameter_shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + "scalar_data": 2011, + "scalar_equalities": 81, + "scalar_inequalities": 152, + "scalar_variables": 112, + "temporal_assembly": "stepwise", + "variable_object_count": 32, + "variable_schema": [ + { + "name": "Pg", + "shapes": [ + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ] + ] + }, + { + "name": "b", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + }, + { + "name": "p_flows", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "soc", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + } + ] + }, + "source_structure_sha256": "fa6f687c34830c880d8270fba754a0e47c16714c3a43de12b4e9a0fdbbbd2e0d", + "timing_seconds": { + "canonicalization": 0.03083491703728214, + "construction": 0.010178625001572073, + "extraction": 0.00025758298579603434, + "solve_after_explicit_canonicalization": 0.002216749999206513 + } + }, + { + "artifact_bytes": 18795, + "artifact_sha256": "fcbeb307fbda8c22be54bb03dab296b5925e14e8bfc5fc9e92b18ab62bfded8a", + "audit_inputs_sha256": "568af6c3cb77d57e6c1d64f6fab3a2a719c91c3d755dfc4aa407055161e6eeec", + "canonical_structure": { + "backend": "CPP", + "canonical_variable_count": 648, + "coefficient_columns": 648, + "coefficient_nonzeros": 2160, + "coefficient_rows": 1249, + "equality_rows": 313, + "exponential_cones": 0, + "formulation": "lossy_dc", + "nonnegative_rows": 936, + "positive_semidefinite_cones": [], + "power_cones_3d": [], + "quadratic_nonzeros": 216, + "reduction_chain": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "second_order_cones": [], + "solver": "CLARABEL", + "temporal_assembly": "stepwise" + }, + "canonical_structure_sha256": "d4278b12d1062a438a90e8d7bbca493fc926aa29534e1774a92d3537a2296882", + "case": "case9", + "classification": "completed", + "formulation": "lossy_dc", + "horizon": 24, + "log_sha256": "9f86dfcc7341773aa0eaecd34ba358bd0a94e73d1d4edd11abf856e06fba969d", + "maximum_residual": 1.4210854715202004e-14, + "peak_rss_bytes": { + "after_canonicalization": 159875072, + "after_construction": 148258816, + "after_extraction": 160989184, + "after_solve": 160989184 + }, + "phase_journal_sha256": "c71bb1645fbfdba91a9ba4a68e46b8c80e053ab588ac40a3d0669972ae58aebe", + "result_schema_sha256": "ed9f5111c8a1a6695846dfbdb3cb35b00bea7932a49b81496d27d4506533b049", + "result_sha256": "a398b7d8cbba6d1646cadf300a426e9bdc15e56f9f98bc50e6d98dd912b21534", + "returncode": 0, + "scientific_scalars": { + "objective": 125185.56793090429, + "storage_cost": 1.1124243594167098e-14 + }, + "serialized_result_bytes": 12269, + "source_structure": { + "constraint_object_count": 217, + "data_keys": [ + "A", + "Cg", + "Cload", + "Cs", + "Pd_series", + "Pgmax", + "Pgmin", + "T", + "baseMVA", + "ext_to_int", + "f_max", + "gen_bus", + "gencost", + "load_bus_external", + "load_bus_internal", + "load_device_ids", + "load_has_reactive", + "load_is_sheddable", + "load_max_shed_fraction", + "load_shedding_cost_per_mwh", + "loss_weight", + "nb", + "ng", + "nl", + "nload", + "ns", + "nsheddable", + "r", + "sheddable_load_device_ids", + "sheddable_load_indices", + "storage_aging_weight", + "storage_apparent_power_rating", + "storage_bus", + "storage_capacity", + "storage_delta", + "storage_device_id_is_explicit", + "storage_device_ids", + "storage_initial_soc", + "storage_terminal_constraint", + "storage_terminal_cost", + "storage_terminal_soc", + "storage_terminal_weight" + ], + "equality_object_count": 49, + "expression_schema": [ + { + "name": "dc_loss_cost", + "shapes": [ + [] + ] + }, + { + "name": "generator_cost", + "shapes": [ + [] + ] + }, + { + "name": "p_load", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "p_load_served", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "p_net", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "q_load", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "storage_cost", + "shapes": [ + [] + ] + } + ], + "formulation": "lossy_dc", + "horizon": 24, + "inequality_object_count": 168, + "other_constraint_object_count": 0, + "parameter_object_count": 48, + "parameter_schema": [ + { + "name": "load_inv_base_mva", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ] + }, + { + "name": "storage_inv_baseMVA", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ] + } + ], + "parameter_shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + "scalar_data": 6027, + "scalar_equalities": 241, + "scalar_inequalities": 456, + "scalar_variables": 336, + "temporal_assembly": "stepwise", + "variable_object_count": 96, + "variable_schema": [ + { + "name": "Pg", + "shapes": [ + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ] + ] + }, + { + "name": "b", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + }, + { + "name": "p_flows", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "soc", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + } + ] + }, + "source_structure_sha256": "d3f461a5635147103d439bc590dd542a948c55c85a7fdd38a6c760c74e6baf6f", + "timing_seconds": { + "canonicalization": 0.10069629194913432, + "construction": 0.023595959006343037, + "extraction": 0.0005643339827656746, + "solve_after_explicit_canonicalization": 0.005038708972278982 + } + }, + { + "artifact_bytes": 96974, + "artifact_sha256": "a48a556298078d4543357d42b806db284fb9714ec357594545c3497111c8dc52", + "audit_inputs_sha256": "568af6c3cb77d57e6c1d64f6fab3a2a719c91c3d755dfc4aa407055161e6eeec", + "canonical_structure": { + "backend": "CPP", + "canonical_variable_count": 4536, + "coefficient_columns": 4536, + "coefficient_nonzeros": 15120, + "coefficient_rows": 8737, + "equality_rows": 2185, + "exponential_cones": 0, + "formulation": "lossy_dc", + "nonnegative_rows": 6552, + "positive_semidefinite_cones": [], + "power_cones_3d": [], + "quadratic_nonzeros": 1512, + "reduction_chain": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "second_order_cones": [], + "solver": "CLARABEL", + "temporal_assembly": "stepwise" + }, + "canonical_structure_sha256": "4cbf8b67ecf4da8b602b9b6d4f8d9349786f1e908c5ac0c8059c8d6eed24cc00", + "case": "case9", + "classification": "completed", + "formulation": "lossy_dc", + "horizon": 168, + "log_sha256": "80f279e5e953c06ed4fcc43fb36c7e92d59771a5d28bd3fa72429a64ff1d0239", + "maximum_residual": 1.4210854715202004e-14, + "peak_rss_bytes": { + "after_canonicalization": 235864064, + "after_construction": 159875072, + "after_extraction": 242040832, + "after_solve": 242024448 + }, + "phase_journal_sha256": "3436f17231683d610eb33128d93dd1714172849f1667de3c53df5eb02eb3db9f", + "result_schema_sha256": "601cc8cbedd3ff3904844d434a2a88f23a6b18ee6a424069dd8ca460ce0e0c66", + "result_sha256": "50adb417586f78d154d7216dcaa20d0ef6b354eb0567f65d49b95518178dae7e", + "returncode": 0, + "scientific_scalars": { + "objective": 876298.9755163315, + "storage_cost": 7.373155549629587e-12 + }, + "serialized_result_bytes": 84092, + "source_structure": { + "constraint_object_count": 1513, + "data_keys": [ + "A", + "Cg", + "Cload", + "Cs", + "Pd_series", + "Pgmax", + "Pgmin", + "T", + "baseMVA", + "ext_to_int", + "f_max", + "gen_bus", + "gencost", + "load_bus_external", + "load_bus_internal", + "load_device_ids", + "load_has_reactive", + "load_is_sheddable", + "load_max_shed_fraction", + "load_shedding_cost_per_mwh", + "loss_weight", + "nb", + "ng", + "nl", + "nload", + "ns", + "nsheddable", + "r", + "sheddable_load_device_ids", + "sheddable_load_indices", + "storage_aging_weight", + "storage_apparent_power_rating", + "storage_bus", + "storage_capacity", + "storage_delta", + "storage_device_id_is_explicit", + "storage_device_ids", + "storage_initial_soc", + "storage_terminal_constraint", + "storage_terminal_cost", + "storage_terminal_soc", + "storage_terminal_weight" + ], + "equality_object_count": 337, + "expression_schema": [ + { + "name": "dc_loss_cost", + "shapes": [ + [] + ] + }, + { + "name": "generator_cost", + "shapes": [ + [] + ] + }, + { + "name": "p_load", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "p_load_served", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "p_net", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "q_load", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "storage_cost", + "shapes": [ + [] + ] + } + ], + "formulation": "lossy_dc", + "horizon": 168, + "inequality_object_count": 1176, + "other_constraint_object_count": 0, + "parameter_object_count": 336, + "parameter_schema": [ + { + "name": "load_inv_base_mva", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ] + }, + { + "name": "storage_inv_baseMVA", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ] + } + ], + "parameter_shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + "scalar_data": 42171, + "scalar_equalities": 1681, + "scalar_inequalities": 3192, + "scalar_variables": 2352, + "temporal_assembly": "stepwise", + "variable_object_count": 672, + "variable_schema": [ + { + "name": "Pg", + "shapes": [ + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ] + ] + }, + { + "name": "b", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + }, + { + "name": "p_flows", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "soc", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + } + ] + }, + "source_structure_sha256": "790f044b2d050b029070ef37eeadded142e8b7be3fddc7fa4674420a3537c60a", + "timing_seconds": { + "canonicalization": 0.6971009169938043, + "construction": 0.1549324169754982, + "extraction": 0.004038999963086098, + "solve_after_explicit_canonicalization": 0.03356029203860089 + } + }, + { + "artifact_bytes": 5231, + "artifact_sha256": "066a46aabe6bb65beb106aa96e9e8f24b2ac07c24184e39605cd455c38ec9769", + "audit_inputs_sha256": "60468757a4f49624b9c0b4329a51f9af12bb506a1d2ac2e7a87f95b629f1ec3f", + "canonical_structure": { + "backend": "CPP", + "canonical_variable_count": 9, + "coefficient_columns": 9, + "coefficient_nonzeros": 27, + "coefficient_rows": 18, + "equality_rows": 6, + "exponential_cones": 0, + "formulation": "singlenode_dc", + "nonnegative_rows": 12, + "positive_semidefinite_cones": [], + "power_cones_3d": [], + "quadratic_nonzeros": 3, + "reduction_chain": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "second_order_cones": [], + "solver": "CLARABEL", + "temporal_assembly": "stepwise" + }, + "canonical_structure_sha256": "031b41eab603038963ec7fcf5b226c21d0c2c8e03fa2f9a97ed7e011ffa57c7e", + "case": "case9", + "classification": "completed", + "formulation": "singlenode_dc", + "horizon": 1, + "log_sha256": "9f86dfcc7341773aa0eaecd34ba358bd0a94e73d1d4edd11abf856e06fba969d", + "maximum_residual": 4.4619962651822403e-14, + "peak_rss_bytes": { + "after_canonicalization": 147308544, + "after_construction": 145784832, + "after_extraction": 147816448, + "after_solve": 147816448 + }, + "phase_journal_sha256": "8e081ac2f638a55561f01cdb9d72fa8de4bdffcd0380efb96fe4e553d7d73134", + "result_schema_sha256": "2d979b9a3933a4168164341efd251624aa0b6cb3c5066e35512d6a8ba5a4cb19", + "result_sha256": "19d637621706806bedb1a9ad26ad21909defc2f7677a2c83102ecc625aa2a9ad", + "returncode": 0, + "scientific_scalars": { + "objective": 5216.026607747272, + "storage_cost": 2.110416668161444e-18 + }, + "serialized_result_bytes": 543, + "source_structure": { + "constraint_object_count": 9, + "data_keys": [ + "Cg", + "Cload", + "Cs", + "Pd_series", + "Pgmax", + "Pgmin", + "T", + "baseMVA", + "ext_to_int", + "gen_bus", + "gencost", + "load_bus_external", + "load_bus_internal", + "load_device_ids", + "load_has_reactive", + "load_is_sheddable", + "load_max_shed_fraction", + "load_shedding_cost_per_mwh", + "nb", + "ng", + "nload", + "ns", + "nsheddable", + "sheddable_load_device_ids", + "sheddable_load_indices", + "source_nb", + "storage_aging_weight", + "storage_apparent_power_rating", + "storage_bus", + "storage_capacity", + "storage_delta", + "storage_device_id_is_explicit", + "storage_device_ids", + "storage_initial_soc", + "storage_terminal_constraint", + "storage_terminal_cost", + "storage_terminal_soc", + "storage_terminal_weight" + ], + "equality_object_count": 3, + "expression_schema": [ + { + "name": "generator_cost", + "shapes": [ + [] + ] + }, + { + "name": "p_load", + "shapes": [ + [ + 9 + ] + ] + }, + { + "name": "p_load_served", + "shapes": [ + [ + 9 + ] + ] + }, + { + "name": "p_net", + "shapes": [ + [] + ] + }, + { + "name": "q_load", + "shapes": [ + [ + 9 + ] + ] + }, + { + "name": "storage_cost", + "shapes": [ + [] + ] + } + ], + "formulation": "singlenode_dc", + "horizon": 1, + "inequality_object_count": 6, + "other_constraint_object_count": 0, + "parameter_object_count": 2, + "parameter_schema": [ + { + "name": "load_inv_base_mva", + "shapes": [ + [] + ] + }, + { + "name": "storage_inv_baseMVA", + "shapes": [ + [] + ] + } + ], + "parameter_shapes": [ + [], + [] + ], + "scalar_data": 50, + "scalar_equalities": 3, + "scalar_inequalities": 10, + "scalar_variables": 5, + "temporal_assembly": "stepwise", + "variable_object_count": 3, + "variable_schema": [ + { + "name": "Pg", + "shapes": [ + [ + 3 + ] + ] + }, + { + "name": "b", + "shapes": [ + [ + 1 + ] + ] + }, + { + "name": "soc", + "shapes": [ + [ + 1 + ] + ] + } + ] + }, + "source_structure_sha256": "1ecda385d95bdfc108be83f083d27d7ba8a990d793855d3db10db2de05dcb90e", + "timing_seconds": { + "canonicalization": 0.0068199579836800694, + "construction": 0.004059250000864267, + "extraction": 9.766599396243691e-05, + "solve_after_explicit_canonicalization": 0.000993124966043979 + } + }, + { + "artifact_bytes": 5463, + "artifact_sha256": "9be589936a9fabc670185f3bd2a70110a050de20aba6bf107afa433c753ead2b", + "audit_inputs_sha256": "60468757a4f49624b9c0b4329a51f9af12bb506a1d2ac2e7a87f95b629f1ec3f", + "canonical_structure": { + "backend": "CPP", + "canonical_variable_count": 18, + "coefficient_columns": 18, + "coefficient_nonzeros": 54, + "coefficient_rows": 35, + "equality_rows": 11, + "exponential_cones": 0, + "formulation": "singlenode_dc", + "nonnegative_rows": 24, + "positive_semidefinite_cones": [], + "power_cones_3d": [], + "quadratic_nonzeros": 6, + "reduction_chain": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "second_order_cones": [], + "solver": "CLARABEL", + "temporal_assembly": "stepwise" + }, + "canonical_structure_sha256": "13a9d48510423c464c439f550aa0254604dd8d5a3b7872ec636a234634365a91", + "case": "case9", + "classification": "completed", + "formulation": "singlenode_dc", + "horizon": 2, + "log_sha256": "9f86dfcc7341773aa0eaecd34ba358bd0a94e73d1d4edd11abf856e06fba969d", + "maximum_residual": 5.076245381513464e-14, + "peak_rss_bytes": { + "after_canonicalization": 147570688, + "after_construction": 145604608, + "after_extraction": 148078592, + "after_solve": 148078592 + }, + "phase_journal_sha256": "19bf3803938b68c9da9b4c939a2513fd653b183a41573ec2d9a7deb869b9d972", + "result_schema_sha256": "35840e680698e47e48d7736701e1b93690b3fae36b5f581d1fd587e6168d11ad", + "result_sha256": "a0df0b540bcbee58805bb4cf04554f739fb3ac82f547791a341cab0912435c4c", + "returncode": 0, + "scientific_scalars": { + "objective": 10432.053215494549, + "storage_cost": 1.243228894981317e-16 + }, + "serialized_result_bytes": 749, + "source_structure": { + "constraint_object_count": 17, + "data_keys": [ + "Cg", + "Cload", + "Cs", + "Pd_series", + "Pgmax", + "Pgmin", + "T", + "baseMVA", + "ext_to_int", + "gen_bus", + "gencost", + "load_bus_external", + "load_bus_internal", + "load_device_ids", + "load_has_reactive", + "load_is_sheddable", + "load_max_shed_fraction", + "load_shedding_cost_per_mwh", + "nb", + "ng", + "nload", + "ns", + "nsheddable", + "sheddable_load_device_ids", + "sheddable_load_indices", + "source_nb", + "storage_aging_weight", + "storage_apparent_power_rating", + "storage_bus", + "storage_capacity", + "storage_delta", + "storage_device_id_is_explicit", + "storage_device_ids", + "storage_initial_soc", + "storage_terminal_constraint", + "storage_terminal_cost", + "storage_terminal_soc", + "storage_terminal_weight" + ], + "equality_object_count": 5, + "expression_schema": [ + { + "name": "generator_cost", + "shapes": [ + [] + ] + }, + { + "name": "p_load", + "shapes": [ + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "p_load_served", + "shapes": [ + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "p_net", + "shapes": [ + [], + [] + ] + }, + { + "name": "q_load", + "shapes": [ + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "storage_cost", + "shapes": [ + [] + ] + } + ], + "formulation": "singlenode_dc", + "horizon": 2, + "inequality_object_count": 12, + "other_constraint_object_count": 0, + "parameter_object_count": 4, + "parameter_schema": [ + { + "name": "load_inv_base_mva", + "shapes": [ + [], + [] + ] + }, + { + "name": "storage_inv_baseMVA", + "shapes": [ + [], + [] + ] + } + ], + "parameter_shapes": [ + [], + [], + [], + [] + ], + "scalar_data": 97, + "scalar_equalities": 5, + "scalar_inequalities": 20, + "scalar_variables": 10, + "temporal_assembly": "stepwise", + "variable_object_count": 6, + "variable_schema": [ + { + "name": "Pg", + "shapes": [ + [ + 3 + ], + [ + 3 + ] + ] + }, + { + "name": "b", + "shapes": [ + [ + 1 + ], + [ + 1 + ] + ] + }, + { + "name": "soc", + "shapes": [ + [ + 1 + ], + [ + 1 + ] + ] + } + ] + }, + "source_structure_sha256": "4818246559fb98ee39b74679229d49a45ec95915850b013a8b718e0f605486f8", + "timing_seconds": { + "canonicalization": 0.009015332965645939, + "construction": 0.00461487501161173, + "extraction": 0.00011612498201429844, + "solve_after_explicit_canonicalization": 0.0009353749919682741 + } + }, + { + "artifact_bytes": 6067, + "artifact_sha256": "f3114391eff037102373427f7a844f66f49a4769a821579504291708707af850", + "audit_inputs_sha256": "60468757a4f49624b9c0b4329a51f9af12bb506a1d2ac2e7a87f95b629f1ec3f", + "canonical_structure": { + "backend": "CPP", + "canonical_variable_count": 36, + "coefficient_columns": 36, + "coefficient_nonzeros": 108, + "coefficient_rows": 69, + "equality_rows": 21, + "exponential_cones": 0, + "formulation": "singlenode_dc", + "nonnegative_rows": 48, + "positive_semidefinite_cones": [], + "power_cones_3d": [], + "quadratic_nonzeros": 12, + "reduction_chain": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "second_order_cones": [], + "solver": "CLARABEL", + "temporal_assembly": "stepwise" + }, + "canonical_structure_sha256": "afcce5307ceda9be49c82158b89c9ca0746ee82b77872b475bd13f61ccb71242", + "case": "case9", + "classification": "completed", + "formulation": "singlenode_dc", + "horizon": 4, + "log_sha256": "9f86dfcc7341773aa0eaecd34ba358bd0a94e73d1d4edd11abf856e06fba969d", + "maximum_residual": 2.5904199399055166e-14, + "peak_rss_bytes": { + "after_canonicalization": 148291584, + "after_construction": 145653760, + "after_extraction": 148783104, + "after_solve": 148783104 + }, + "phase_journal_sha256": "e8ef5ff9f8ca5a7e48c7d75a96ac5659b1a7a0fb52994640c4397bf7fe051555", + "result_schema_sha256": "1e71102ef80e082cb24c511c76da2350e04f4e5d139288dbe73e583081f7a7ef", + "result_sha256": "09dea6502e45ccfdef33a6dda0d7c91f200408a9cceefc24ba6f75aede238ea0", + "returncode": 0, + "scientific_scalars": { + "objective": 20864.106430989093, + "storage_cost": 1.2420150894754238e-15 + }, + "serialized_result_bytes": 1269, + "source_structure": { + "constraint_object_count": 33, + "data_keys": [ + "Cg", + "Cload", + "Cs", + "Pd_series", + "Pgmax", + "Pgmin", + "T", + "baseMVA", + "ext_to_int", + "gen_bus", + "gencost", + "load_bus_external", + "load_bus_internal", + "load_device_ids", + "load_has_reactive", + "load_is_sheddable", + "load_max_shed_fraction", + "load_shedding_cost_per_mwh", + "nb", + "ng", + "nload", + "ns", + "nsheddable", + "sheddable_load_device_ids", + "sheddable_load_indices", + "source_nb", + "storage_aging_weight", + "storage_apparent_power_rating", + "storage_bus", + "storage_capacity", + "storage_delta", + "storage_device_id_is_explicit", + "storage_device_ids", + "storage_initial_soc", + "storage_terminal_constraint", + "storage_terminal_cost", + "storage_terminal_soc", + "storage_terminal_weight" + ], + "equality_object_count": 9, + "expression_schema": [ + { + "name": "generator_cost", + "shapes": [ + [] + ] + }, + { + "name": "p_load", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "p_load_served", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "p_net", + "shapes": [ + [], + [], + [], + [] + ] + }, + { + "name": "q_load", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "storage_cost", + "shapes": [ + [] + ] + } + ], + "formulation": "singlenode_dc", + "horizon": 4, + "inequality_object_count": 24, + "other_constraint_object_count": 0, + "parameter_object_count": 8, + "parameter_schema": [ + { + "name": "load_inv_base_mva", + "shapes": [ + [], + [], + [], + [] + ] + }, + { + "name": "storage_inv_baseMVA", + "shapes": [ + [], + [], + [], + [] + ] + } + ], + "parameter_shapes": [ + [], + [], + [], + [], + [], + [], + [], + [] + ], + "scalar_data": 191, + "scalar_equalities": 9, + "scalar_inequalities": 40, + "scalar_variables": 20, + "temporal_assembly": "stepwise", + "variable_object_count": 12, + "variable_schema": [ + { + "name": "Pg", + "shapes": [ + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ] + ] + }, + { + "name": "b", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + }, + { + "name": "soc", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + } + ] + }, + "source_structure_sha256": "1e4a101d24c7081b2d4ae0e73ca758f64a6805848d9b1013b6f284354ff0caaf", + "timing_seconds": { + "canonicalization": 0.01457508298335597, + "construction": 0.006155124981887639, + "extraction": 0.00012183398939669132, + "solve_after_explicit_canonicalization": 0.0010789170046336949 + } + }, + { + "artifact_bytes": 7223, + "artifact_sha256": "4b56198f94ad648e6b9f8f4b7faebc87f6153bde6b39ce24cf998f4adecc4efa", + "audit_inputs_sha256": "60468757a4f49624b9c0b4329a51f9af12bb506a1d2ac2e7a87f95b629f1ec3f", + "canonical_structure": { + "backend": "CPP", + "canonical_variable_count": 72, + "coefficient_columns": 72, + "coefficient_nonzeros": 216, + "coefficient_rows": 137, + "equality_rows": 41, + "exponential_cones": 0, + "formulation": "singlenode_dc", + "nonnegative_rows": 96, + "positive_semidefinite_cones": [], + "power_cones_3d": [], + "quadratic_nonzeros": 24, + "reduction_chain": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "second_order_cones": [], + "solver": "CLARABEL", + "temporal_assembly": "stepwise" + }, + "canonical_structure_sha256": "202c5df8f5f548d80e2f10dafbeccda277c0b450ebd8d99f0b2ffd0ba8a48a99", + "case": "case9", + "classification": "completed", + "formulation": "singlenode_dc", + "horizon": 8, + "log_sha256": "9f86dfcc7341773aa0eaecd34ba358bd0a94e73d1d4edd11abf856e06fba969d", + "maximum_residual": 5.766354710078212e-14, + "peak_rss_bytes": { + "after_canonicalization": 150175744, + "after_construction": 145997824, + "after_extraction": 150700032, + "after_solve": 150700032 + }, + "phase_journal_sha256": "6a8ca7c11751f62bf7b76ffc18240ee3892dc43694a642e20321681699ccc2b3", + "result_schema_sha256": "32dc24a471b1cabe835090351cf44af0d20e7936ec64b8eef47d5db12d61b196", + "result_sha256": "862862a0b64deb4a0ba31f8f3e13c4d6f29d6061e90b7f404718e96a67d257ee", + "returncode": 0, + "scientific_scalars": { + "objective": 41728.21286197819, + "storage_cost": 6.361762807191671e-16 + }, + "serialized_result_bytes": 2267, + "source_structure": { + "constraint_object_count": 65, + "data_keys": [ + "Cg", + "Cload", + "Cs", + "Pd_series", + "Pgmax", + "Pgmin", + "T", + "baseMVA", + "ext_to_int", + "gen_bus", + "gencost", + "load_bus_external", + "load_bus_internal", + "load_device_ids", + "load_has_reactive", + "load_is_sheddable", + "load_max_shed_fraction", + "load_shedding_cost_per_mwh", + "nb", + "ng", + "nload", + "ns", + "nsheddable", + "sheddable_load_device_ids", + "sheddable_load_indices", + "source_nb", + "storage_aging_weight", + "storage_apparent_power_rating", + "storage_bus", + "storage_capacity", + "storage_delta", + "storage_device_id_is_explicit", + "storage_device_ids", + "storage_initial_soc", + "storage_terminal_constraint", + "storage_terminal_cost", + "storage_terminal_soc", + "storage_terminal_weight" + ], + "equality_object_count": 17, + "expression_schema": [ + { + "name": "generator_cost", + "shapes": [ + [] + ] + }, + { + "name": "p_load", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "p_load_served", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "p_net", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [] + ] + }, + { + "name": "q_load", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "storage_cost", + "shapes": [ + [] + ] + } + ], + "formulation": "singlenode_dc", + "horizon": 8, + "inequality_object_count": 48, + "other_constraint_object_count": 0, + "parameter_object_count": 16, + "parameter_schema": [ + { + "name": "load_inv_base_mva", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [] + ] + }, + { + "name": "storage_inv_baseMVA", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [] + ] + } + ], + "parameter_shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + "scalar_data": 379, + "scalar_equalities": 17, + "scalar_inequalities": 80, + "scalar_variables": 40, + "temporal_assembly": "stepwise", + "variable_object_count": 24, + "variable_schema": [ + { + "name": "Pg", + "shapes": [ + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ] + ] + }, + { + "name": "b", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + }, + { + "name": "soc", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + } + ] + }, + "source_structure_sha256": "f9c9597fee4dcf9a34aa36835b6b591bd65a6eeff3b237e5421522010bb92d06", + "timing_seconds": { + "canonicalization": 0.025282374990638345, + "construction": 0.009118542016949505, + "extraction": 0.00017166603356599808, + "solve_after_explicit_canonicalization": 0.00146808399586007 + } + }, + { + "artifact_bytes": 11924, + "artifact_sha256": "eed6379e4358329adee75deebfdc1c170c214b789ec7a70502ba737cd2558983", + "audit_inputs_sha256": "60468757a4f49624b9c0b4329a51f9af12bb506a1d2ac2e7a87f95b629f1ec3f", + "canonical_structure": { + "backend": "CPP", + "canonical_variable_count": 216, + "coefficient_columns": 216, + "coefficient_nonzeros": 648, + "coefficient_rows": 409, + "equality_rows": 121, + "exponential_cones": 0, + "formulation": "singlenode_dc", + "nonnegative_rows": 288, + "positive_semidefinite_cones": [], + "power_cones_3d": [], + "quadratic_nonzeros": 72, + "reduction_chain": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "second_order_cones": [], + "solver": "CLARABEL", + "temporal_assembly": "stepwise" + }, + "canonical_structure_sha256": "3e3901100cd039ba7dfa2d8102b39572c82a30209efaacc520de8f90afb1c524", + "case": "case9", + "classification": "completed", + "formulation": "singlenode_dc", + "horizon": 24, + "log_sha256": "9f86dfcc7341773aa0eaecd34ba358bd0a94e73d1d4edd11abf856e06fba969d", + "maximum_residual": 6.803446189463346e-14, + "peak_rss_bytes": { + "after_canonicalization": 156614656, + "after_construction": 147472384, + "after_extraction": 157319168, + "after_solve": 157302784 + }, + "phase_journal_sha256": "db49e701f6d6253b162f76996b367dd645314bdf847b94f2039cac5ac733cc32", + "result_schema_sha256": "e22320ebdc48f9e13af439e80beda9e0977f1b9b01f5b24cbf69be20a82665d5", + "result_sha256": "b80f57cacaf4c412b8abc6504548f6dd2e5ced41cb066a10347c6fb56c12540b", + "returncode": 0, + "scientific_scalars": { + "objective": 125184.63858593459, + "storage_cost": 2.5134654795069967e-16 + }, + "serialized_result_bytes": 6326, + "source_structure": { + "constraint_object_count": 193, + "data_keys": [ + "Cg", + "Cload", + "Cs", + "Pd_series", + "Pgmax", + "Pgmin", + "T", + "baseMVA", + "ext_to_int", + "gen_bus", + "gencost", + "load_bus_external", + "load_bus_internal", + "load_device_ids", + "load_has_reactive", + "load_is_sheddable", + "load_max_shed_fraction", + "load_shedding_cost_per_mwh", + "nb", + "ng", + "nload", + "ns", + "nsheddable", + "sheddable_load_device_ids", + "sheddable_load_indices", + "source_nb", + "storage_aging_weight", + "storage_apparent_power_rating", + "storage_bus", + "storage_capacity", + "storage_delta", + "storage_device_id_is_explicit", + "storage_device_ids", + "storage_initial_soc", + "storage_terminal_constraint", + "storage_terminal_cost", + "storage_terminal_soc", + "storage_terminal_weight" + ], + "equality_object_count": 49, + "expression_schema": [ + { + "name": "generator_cost", + "shapes": [ + [] + ] + }, + { + "name": "p_load", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "p_load_served", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "p_net", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ] + }, + { + "name": "q_load", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "storage_cost", + "shapes": [ + [] + ] + } + ], + "formulation": "singlenode_dc", + "horizon": 24, + "inequality_object_count": 144, + "other_constraint_object_count": 0, + "parameter_object_count": 48, + "parameter_schema": [ + { + "name": "load_inv_base_mva", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ] + }, + { + "name": "storage_inv_baseMVA", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ] + } + ], + "parameter_shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + "scalar_data": 1131, + "scalar_equalities": 49, + "scalar_inequalities": 240, + "scalar_variables": 120, + "temporal_assembly": "stepwise", + "variable_object_count": 72, + "variable_schema": [ + { + "name": "Pg", + "shapes": [ + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ] + ] + }, + { + "name": "b", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + }, + { + "name": "soc", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + } + ] + }, + "source_structure_sha256": "485d3356e486b19b7ce90ea957d520572f01f84964dfa5b617e8276480975bf6", + "timing_seconds": { + "canonicalization": 0.07071083300979808, + "construction": 0.020566833030898124, + "extraction": 0.00046620803186669946, + "solve_after_explicit_canonicalization": 0.003233040974009782 + } + }, + { + "artifact_bytes": 53623, + "artifact_sha256": "0a2e2849852e72d56c61152275c18d8dde3e8ed8b261df8f92bb824340f8eaad", + "audit_inputs_sha256": "60468757a4f49624b9c0b4329a51f9af12bb506a1d2ac2e7a87f95b629f1ec3f", + "canonical_structure": { + "backend": "CPP", + "canonical_variable_count": 1512, + "coefficient_columns": 1512, + "coefficient_nonzeros": 4536, + "coefficient_rows": 2857, + "equality_rows": 841, + "exponential_cones": 0, + "formulation": "singlenode_dc", + "nonnegative_rows": 2016, + "positive_semidefinite_cones": [], + "power_cones_3d": [], + "quadratic_nonzeros": 504, + "reduction_chain": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "second_order_cones": [], + "solver": "CLARABEL", + "temporal_assembly": "stepwise" + }, + "canonical_structure_sha256": "ae22130cab6d4a4067cc7b92813ac5eb84ca1b76a0de0c22e7e5b285ad14c39b", + "case": "case9", + "classification": "completed", + "formulation": "singlenode_dc", + "horizon": 168, + "log_sha256": "9f86dfcc7341773aa0eaecd34ba358bd0a94e73d1d4edd11abf856e06fba969d", + "maximum_residual": 9.540060260130233e-14, + "peak_rss_bytes": { + "after_canonicalization": 215072768, + "after_construction": 157466624, + "after_extraction": 217366528, + "after_solve": 217333760 + }, + "phase_journal_sha256": "793a8eec073b7fdfe30dcfd14e5ec01d4b6a271035b706b33737f5cda2b83186", + "result_schema_sha256": "9a4497214545de0a96d01b8c4671c6707ff0a57ad17784f1695c47c412e15d9e", + "result_sha256": "f7f09b871c3bdb3e7a5cb808517905af5167f2bf44cfe419aef4e3543aedb594", + "returncode": 0, + "scientific_scalars": { + "objective": 876292.4701015501, + "storage_cost": 6.065951602370982e-13 + }, + "serialized_result_bytes": 42389, + "source_structure": { + "constraint_object_count": 1345, + "data_keys": [ + "Cg", + "Cload", + "Cs", + "Pd_series", + "Pgmax", + "Pgmin", + "T", + "baseMVA", + "ext_to_int", + "gen_bus", + "gencost", + "load_bus_external", + "load_bus_internal", + "load_device_ids", + "load_has_reactive", + "load_is_sheddable", + "load_max_shed_fraction", + "load_shedding_cost_per_mwh", + "nb", + "ng", + "nload", + "ns", + "nsheddable", + "sheddable_load_device_ids", + "sheddable_load_indices", + "source_nb", + "storage_aging_weight", + "storage_apparent_power_rating", + "storage_bus", + "storage_capacity", + "storage_delta", + "storage_device_id_is_explicit", + "storage_device_ids", + "storage_initial_soc", + "storage_terminal_constraint", + "storage_terminal_cost", + "storage_terminal_soc", + "storage_terminal_weight" + ], + "equality_object_count": 337, + "expression_schema": [ + { + "name": "generator_cost", + "shapes": [ + [] + ] + }, + { + "name": "p_load", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "p_load_served", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "p_net", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ] + }, + { + "name": "q_load", + "shapes": [ + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ], + [ + 9 + ] + ] + }, + { + "name": "storage_cost", + "shapes": [ + [] + ] + } + ], + "formulation": "singlenode_dc", + "horizon": 168, + "inequality_object_count": 1008, + "other_constraint_object_count": 0, + "parameter_object_count": 336, + "parameter_schema": [ + { + "name": "load_inv_base_mva", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ] + }, + { + "name": "storage_inv_baseMVA", + "shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ] + } + ], + "parameter_shapes": [ + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [], + [] + ], + "scalar_data": 7899, + "scalar_equalities": 337, + "scalar_inequalities": 1680, + "scalar_variables": 840, + "temporal_assembly": "stepwise", + "variable_object_count": 504, + "variable_schema": [ + { + "name": "Pg", + "shapes": [ + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ], + [ + 3 + ] + ] + }, + { + "name": "b", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + }, + { + "name": "soc", + "shapes": [ + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ] + ] + } + ] + }, + "source_structure_sha256": "63a19c50c6825c091994e7671d59b1344989941cf6620f95db0e7ba848b3cdf9", + "timing_seconds": { + "canonicalization": 0.5574334579869173, + "construction": 0.13748516602208838, + "extraction": 0.002809208002872765, + "solve_after_explicit_canonicalization": 0.019442541990429163 + } + } + ], + "schema_version": 1, + "stage": "M14a_legacy_baseline" + } + }, + "reviewed_worktree_exception": { + "dirty_worker_points": [ + { + "case": "case118", + "formulation": "singlenode_dc", + "git_commit": "1dd5e36dcae5ad9c8176b1d1202f1055acf95c03", + "horizon": 8760, + "source_fingerprint": "02567a6928cede7d51d555affb84107e480a87adf748676f0e2ed2e598232e1b" + } + ], + "execution_commit": "1dd5e36dcae5ad9c8176b1d1202f1055acf95c03", + "execution_source_fingerprint": "02567a6928cede7d51d555affb84107e480a87adf748676f0e2ed2e598232e1b", + "paths": [ + "experiments/dnlp_vs_pypower/REPORT.tex", + "experiments/dnlp_vs_pypower/demo.py", + "presentations/weekly_update_20260826/cvxopf_project_update.synctex(busy)", + "presentations/weekly_update_20260826/cvxopf_project_update.tex" + ], + "reason": "During the final 8760-step worker, the experiment owner corrected an older DNLP experiment while preparing the project presentation. These files are outside the frozen M14 execution-source registry; the execution commit and M14 source fingerprint remained unchanged.", + "reviewed_on": "2026-08-26", + "schema_version": 1, + "scope": "non_execution_worktree_changes" + }, + "schema_version": 1, + "stage": "M14a_legacy_baseline" +} From e741d4ec82ad91e03646d2343488da94604f6c8d Mon Sep 17 00:00:00 2001 From: Bennet Meyers Date: Thu, 27 Aug 2026 14:38:59 -0700 Subject: [PATCH 16/28] docs(m14): mark baseline characterization complete Record the frozen ladder execution commit, clean analyzer commit, and promoted result hash. Mark M14b as the next stage while keeping the Case118 annual solve paused behind the remaining vectorization gates. --- CLAUDE.md | 2 +- plans/milestone-14-time-vectorization.md | 15 ++++++++++++--- 2 files changed, 13 insertions(+), 4 deletions(-) diff --git a/CLAUDE.md b/CLAUDE.md index db8ecfd..0b2c127 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -737,7 +737,7 @@ is present. | 11 — SOCP (convex) network model | 🔲 Future | | | 12 — Extend battery parameters: final SoC, penalty vs constraint | ✅ Complete | Storage-owned terminal equality or zero-shortfall constraints and linear/quadratic, one-/two-sided terminal costs, consistently composed across formulations. See `plans/milestone-12-storage-terminal-soc.md`. | | 13 — Extend CVXPY parameterization for problem data | 🔲 Future | Faster repeated solves of the same graph over new data | -| 14 — Time-vectorized multistep formulations | 🟧 Next / blocking | Add an explicit time-last tensor assembly mode using SCIPY canonicalization alongside the retained stepwise/CPP path, preserving formulation, failure, audit, and result contracts while enabling direct profiling of both temporal representations. Vectorized lossy DC is the first delivery and blocks resumption of the Case118 annual S4 outer solve after macOS killed the repeated annual graph under extreme compressed-memory pressure. See `plans/milestone-14-time-vectorization.md`. | +| 14 — Time-vectorized multistep formulations | 🟧 In progress / blocking | M14a's frozen legacy Case9 and Case118 scaling baseline is complete and authorizes M14b. Next, add the explicit time-last tensor assembly mode using SCIPY canonicalization alongside the retained stepwise/CPP path, preserving formulation, failure, audit, and result contracts. Vectorized lossy DC remains the first delivery and blocks resumption of the Case118 annual S4 outer solve after macOS killed the repeated annual graph under extreme compressed-memory pressure. See `plans/milestone-14-time-vectorization.md`. | | 15 — Full lossy HVDC (sign-switching converter losses) | 🔲 Future | charge/discharge-style split of `p_in`; adds fixed converter loss (`LOSS0`); enables losses in `free` and zero-straddling `band` steps; reactive-power support proposed. See `plans/milestone-15-full-lossy-hvdc.md`. | | 16 — Unify grid component model patterns | ✅ Complete | Generators, storage, nondispatchable units, and HVDC share formulation-specific injection and operating-set APIs, temporal coupling slots, and device-owned cost boundaries. Includes first-class `DispatchableGenerator`, MATPOWER fallback, stable identity for external ND/HVDC tables, and collapsed singlenode reuse. See `plans/milestone-16-unify-components.md` and `memories/M16-in-flight-record.md`. | | 17 — Hierarchical DC→AC receding-horizon dispatch | ✅ Complete | The capstone controller passes **identity-aligned SoC signposts only** (not other setpoints) from long-horizon `lossy_dc` planning into short AC-OPF windows, executes only residual-checked target-conditioned first actions, supports causal shifted initialization with audited recovery, and retains the complete plan/attempt tree. M17 fixes the validated `lossy_dc`→`ac` workflow; configurable formulations and additional layers are M21. See `plans/milestone-17-hierarchical-dc-ac.md`. | diff --git a/plans/milestone-14-time-vectorization.md b/plans/milestone-14-time-vectorization.md index ec74bf7..a9b2a01 100644 --- a/plans/milestone-14-time-vectorization.md +++ b/plans/milestone-14-time-vectorization.md @@ -2,9 +2,18 @@ ## Status -**Required next milestone.** The Case118 annual hierarchy experiment is paused -at S4 until the annual lossy-DC outer problem passes the M14 construction, -canonicalization, solve, equivalence, and resource gates below. +**In progress; M14a complete.** The frozen legacy Case9 and Case118 scaling +ladders completed and the independently reconstructed baseline authorizes M14b. +The immutable record is bound to: + +- execution commit `1dd5e36dcae5ad9c8176b1d1202f1055acf95c03`; +- analyzer commit `457ec9200050eae2a60dd470a131155a0ddaa53f`; and +- promoted-record SHA-256 + `44f6f0b9f3c3b51621f6952dd2efa1eb2d169757895acaba75bba6f04f5edb53`. + +The Case118 annual hierarchy experiment remains paused at S4 until the annual +lossy-DC outer problem passes the remaining M14 construction, +canonicalization, solve, equivalence, and resource gates below. M14b is next. ## Motivation From a911d16af9dc435516641cd699985d26083b661b Mon Sep 17 00:00:00 2001 From: Bennet Meyers Date: Thu, 27 Aug 2026 15:48:44 -0700 Subject: [PATCH 17/28] feat(m14a): qualify vectorized leaf-bound representations Compare explicit inequalities with CVXPY leaf bounds using isolated static and time-varying Case9 fixtures. Qualify tested lossy-DC and single-node boxes with SCIPY/CLARABEL, retain explicit AC bounds pending production-structure evidence, and add independent physical audits, active-face probes, fresh-process execution, provenance, and focused tests. --- .../m14_time_vectorization/M14A1_PROTOCOL.md | 65 ++ .../m14_time_vectorization/m14a1_bounds.py | 676 ++++++++++++++++++ .../m14_time_vectorization/run_m14a1.py | 212 ++++++ tests/test_m14a1_bounds.py | 117 +++ 4 files changed, 1070 insertions(+) create mode 100644 experiments/m14_time_vectorization/M14A1_PROTOCOL.md create mode 100644 experiments/m14_time_vectorization/m14a1_bounds.py create mode 100644 experiments/m14_time_vectorization/run_m14a1.py create mode 100644 tests/test_m14a1_bounds.py diff --git a/experiments/m14_time_vectorization/M14A1_PROTOCOL.md b/experiments/m14_time_vectorization/M14A1_PROTOCOL.md new file mode 100644 index 0000000..6ae77f8 --- /dev/null +++ b/experiments/m14_time_vectorization/M14A1_PROTOCOL.md @@ -0,0 +1,65 @@ +# M14a.1 leaf-bound qualification protocol + +M14a.1 qualifies CVXPY `Variable(bounds=...)` separately for AC, lossy DC, +and single-node DC before M14b can select it for production vectorized +assembly. A convex result never authorizes AC. + +The isolated Case9 fixture uses genuine time-last variables over three hourly +intervals. For each formulation it executes a fixed 2 × 2 matrix: + +- explicit inequalities versus leaf bounds; and +- static bounds represented by zero-copy NumPy broadcast views versus fully + time-varying bound arrays. + +Both encodings receive identical numerical arrays, objective terms, equations, +initial values, canonicalization backend, and solver options. Lossy DC and +single-node DC use SCIPY canonicalization and CLARABEL. AC uses its own dense +nonlinear nodal equations and IPOPT; no inference is made from the convex +paths. This isolated AC graph does not reproduce the production lifted P/Q, +branch-terminal, component-assembly, or storage-terminal-policy graph in which +a Qg leaf bound previously changed solver behavior. AC therefore retains +explicit inequalities regardless of the isolated result until a production- +structure test retires that risk. The fixture covers generator real-power +boxes in all formulations, lossy-DC branch-flow boxes, and isolated AC +reactive-generation and voltage boxes. Component-specific boxes introduced +during M14b remain subject to focused equivalence tests; this gate does not +silently authorize untested boxes. + +Each arm runs in a fresh process so solver-stack state and process-lifetime +peak RSS are not inherited from another formulation or encoding. Each arm +retains source-object counts, explicit inequality counts, scalar +dimensions, solver behavior, objective, result arrays, independently +reconstructed residuals, and phase timings. Convex arms additionally retain +SCIPY canonical cone dimensions and sparse coefficient nonzeros. Pairwise +arms also run a controlled convex probe for every candidate variable family. +The probe alternates coordinates between lower and upper faces and drives the +unconstrained minimizer outside the box, requiring both faces to bind. Every +standalone probe is a DCP-valid box-constrained least-squares problem and uses +CLARABEL with SCIPY canonicalization; it does not route a convex QP through +DNLP. The complete AC qualification fixture separately exercises the leaf +bounds through IPOPT/DNLP. + +AC active and reactive balance are independently reconstructed numerically +from retained `v`, `theta`, `Ybus`, `Pg`, `Qg`, `Pd`, and `Qd`; CVXPY's +constraint-violation evaluator is not used as the physical audit. Pairwise +qualification requires both arms to be accepted and objective/real-dispatch +absolute residuals no larger than `2e-4`; each physical residual must be no +larger than `1e-6`. Raw differences are retained for every modeled variable, +but reactive dispatch, voltage, angle, and network-flow coordinates are not +accidental equality gates when the optimum does not uniquely determine them. +These are short deterministic equivalence tolerances, not claims about all +networks or all solver stacks. + +The authoritative run requires a clean committed tree, records the exact Git +commit, complete M14 source fingerprint, machine, Python, CVXPY, CLARABEL, +cyipopt, IPOPT, NumPy, and SciPy versions, and writes +`M14A1_RESULTS.json` immutably: + +```bash +uv run python -m experiments.m14_time_vectorization.run_m14a1 +``` + +Lossy DC and single-node DC select leaf bounds only if both static and +time-varying pairs and every binding probe pass. AC records the same isolated +evidence but conservatively retains explicit inequalities. Every decision is +local to this frozen gate and remains visible in M14b structural provenance. diff --git a/experiments/m14_time_vectorization/m14a1_bounds.py b/experiments/m14_time_vectorization/m14a1_bounds.py new file mode 100644 index 0000000..95f2106 --- /dev/null +++ b/experiments/m14_time_vectorization/m14a1_bounds.py @@ -0,0 +1,676 @@ +"""Formulation-specific leaf-bound qualification for M14a.1. + +This is an isolated vectorized characterization fixture. It does not change +the public OPF builders or pre-authorize a bound representation for M14b. +""" + +from __future__ import annotations + +from dataclasses import dataclass +import resource +import sys +from typing import Any, Literal, cast +import time + +import cvxpy as cp +import numpy as np + +from cvxopf.cost import poly_cost_expr +from cvxopf.network import ( + make_branch_node_incidence_matrix, + make_incidence_matrix, + make_ybus_matpower, + reindex_case_to_consecutive, +) +from cvxopf.testcases import case9 + + +Formulation = Literal["ac", "lossy_dc", "singlenode_dc"] +BoundEncoding = Literal["explicit", "leaf"] +BoundProfile = Literal["static", "time_varying"] +FORMULATIONS: tuple[Formulation, ...] = ("ac", "lossy_dc", "singlenode_dc") +BOUND_ENCODINGS: tuple[BoundEncoding, ...] = ("explicit", "leaf") +BOUND_PROFILES: tuple[BoundProfile, ...] = ("static", "time_varying") +HORIZON = 3 +AUDIT_TOLERANCE = 1e-6 +PAIR_ABSOLUTE_TOLERANCE = 2e-4 + + +def _peak_rss_bytes() -> int: + raw = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss + return int(raw if sys.platform == "darwin" else raw * 1024) + + +@dataclass(frozen=True) +class QualificationBuild: + """One build-ready paired qualification problem.""" + + formulation: Formulation + encoding: BoundEncoding + profile: BoundProfile + problem: cp.Problem + variables: dict[str, cp.Variable] + inputs: dict[str, np.ndarray | float | int] + + def solve(self, *, convex_probe: bool = False) -> None: + """Solve with the formulation's frozen qualification configuration.""" + if convex_probe: + self.problem.solve(solver=cp.CLARABEL, canon_backend=cp.SCIPY_CANON_BACKEND) + elif self.formulation == "ac": + self.problem.solve( + solver=cp.IPOPT, + nlp=True, + max_iter=500, + print_level=0, + sb="yes", + ) + else: + self.problem.solve(solver=cp.CLARABEL, canon_backend=cp.SCIPY_CANON_BACKEND) + + +def _bounds( + lower: np.ndarray, + upper: np.ndarray, + profile: BoundProfile, +) -> tuple[np.ndarray, np.ndarray]: + """Return static broadcast or fully materialized time-varying boxes.""" + if profile == "static": + shape = (lower.size, HORIZON) + return np.broadcast_to(lower[:, None], shape), np.broadcast_to( + upper[:, None], shape + ) + phase = np.linspace(0.0, 1.0, HORIZON)[None, :] + width = upper - lower + # Move both faces without excluding the nominal Case9 optimum. + return ( + lower[:, None] + 0.002 * width[:, None] * phase, + upper[:, None] - 0.002 * width[:, None] * phase, + ) + + +def _variable( + name: str, + shape: tuple[int, ...], + lower: np.ndarray, + upper: np.ndarray, + encoding: BoundEncoding, +) -> tuple[cp.Variable, list[cp.Constraint]]: + if encoding == "leaf": + return cp.Variable(shape, name=name, bounds=[lower, upper]), [] + variable = cp.Variable(shape, name=name) + return variable, [variable >= lower, variable <= upper] + + +def _case_data(profile: BoundProfile) -> dict[str, Any]: + ppc, _mapping = reindex_case_to_consecutive(cast(dict[str, Any], case9())) + base = float(ppc["baseMVA"]) + bus = np.asarray(ppc["bus"], dtype=float) + gen = np.asarray(ppc["gen"], dtype=float) + pg = _bounds(gen[:, 9] / base, gen[:, 8] / base, profile) + qg = _bounds(gen[:, 4] / base, gen[:, 3] / base, profile) + voltage = _bounds(bus[:, 12], bus[:, 11], profile) + demand_scale = np.array([0.99, 1.0, 1.01]) + return { + "ppc": ppc, + "base": base, + "bus": bus, + "gen": gen, + "Cg": make_incidence_matrix(ppc), + "Pg_lower": pg[0], + "Pg_upper": pg[1], + "Qg_lower": qg[0], + "Qg_upper": qg[1], + "v_lower": voltage[0], + "v_upper": voltage[1], + "Pd": bus[:, 2, None] / base * demand_scale, + "Qd": bus[:, 3, None] / base * demand_scale, + } + + +def _generation_cost(data: dict[str, Any], pg: cp.Variable) -> cp.Expression: + return sum( + ( + poly_cost_expr(data["ppc"]["gencost"], pg[:, step] * data["base"]) + for step in range(HORIZON) + ), + start=cp.Constant(0.0), + ) + + +def build_qualification( + formulation: Formulation, + encoding: BoundEncoding, + profile: BoundProfile, +) -> QualificationBuild: + """Build one Case9 time-last qualification model.""" + if formulation not in FORMULATIONS: + raise ValueError("unsupported formulation") + if encoding not in BOUND_ENCODINGS: + raise ValueError("unsupported bound encoding") + if profile not in BOUND_PROFILES: + raise ValueError("unsupported bound profile") + data = _case_data(profile) + ng = int(data["gen"].shape[0]) + nb = int(data["bus"].shape[0]) + pg, constraints = _variable( + "Pg", + (ng, HORIZON), + data["Pg_lower"], + data["Pg_upper"], + encoding, + ) + variables = {"Pg": pg} + + if formulation == "singlenode_dc": + constraints.append(cp.sum(pg, axis=0) == cp.sum(data["Pd"], axis=0)) + objective = _generation_cost(data, pg) + elif formulation == "lossy_dc": + branch = np.asarray(data["ppc"]["branch"], dtype=float) + nl = int(branch.shape[0]) + flow_limit = branch[:, 5] / data["base"] + flow_limit = np.where(flow_limit == 0.0, 1e4, flow_limit) + flow_profile = _bounds(-flow_limit, flow_limit, profile) + flow, flow_constraints = _variable( + "p_flows", + (nl, HORIZON), + flow_profile[0], + flow_profile[1], + encoding, + ) + variables["p_flows"] = flow + data["p_flows_lower"] = flow_profile[0] + data["p_flows_upper"] = flow_profile[1] + constraints.extend(flow_constraints) + incidence = make_branch_node_incidence_matrix(data["ppc"]) + constraints.append(incidence @ flow + data["Cg"] @ pg - data["Pd"] == 0) + resistance = branch[:, 2, None] + objective = _generation_cost(data, pg) + 1e-3 * cp.sum( + cp.multiply(resistance, cp.square(flow)) + ) + else: + qg, qg_constraints = _variable( + "Qg", + (ng, HORIZON), + data["Qg_lower"], + data["Qg_upper"], + encoding, + ) + voltage, voltage_constraints = _variable( + "v", + (nb, HORIZON), + data["v_lower"], + data["v_upper"], + encoding, + ) + theta = cp.Variable((nb, HORIZON), name="theta") + variables.update(Qg=qg, v=voltage, theta=theta) + constraints.extend(qg_constraints) + constraints.extend(voltage_constraints) + constraints.append(theta[0, :] == 0.0) + admittance = make_ybus_matpower(data["ppc"]) + conductance = admittance.real + susceptance = admittance.imag + data["G"] = conductance + data["B"] = susceptance + for step in range(HORIZON): + angle = theta[:, step, None] - theta[None, :, step] + voltage_product = voltage[:, step, None] @ voltage[None, :, step] + active = cp.sum( + cp.multiply( + voltage_product, + cp.multiply(conductance, cp.nlp.cos(angle)) + + cp.multiply(susceptance, cp.nlp.sin(angle)), + ), + axis=1, + ) + reactive = cp.sum( + cp.multiply( + voltage_product, + cp.multiply(conductance, cp.nlp.sin(angle)) + - cp.multiply(susceptance, cp.nlp.cos(angle)), + ), + axis=1, + ) + constraints.extend( + ( + active == data["Cg"] @ pg[:, step] - data["Pd"][:, step], + reactive == data["Cg"] @ qg[:, step] - data["Qd"][:, step], + ) + ) + objective = _generation_cost(data, pg) + + return QualificationBuild( + formulation, + encoding, + profile, + cp.Problem(cp.Minimize(objective), constraints), + variables, + { + key: value + for key, value in data.items() + if key != "ppc" and isinstance(value, (np.ndarray, float, int)) + }, + ) + + +def _source_structure(build: QualificationBuild) -> dict[str, Any]: + problem = build.problem + metrics = problem.size_metrics + constraints = problem.constraints + return { + "variable_objects": len(problem.variables()), + "constraint_objects": len(constraints), + "equality_objects": sum( + isinstance(item, cp.constraints.Equality) for item in constraints + ), + "explicit_inequality_objects": sum( + isinstance(item, cp.constraints.Inequality) for item in constraints + ), + "scalar_variables": int(metrics.num_scalar_variables), + "scalar_equalities": int(metrics.num_scalar_eq_constr), + "explicit_scalar_inequalities": int(metrics.num_scalar_leq_constr), + "variable_shapes": { + name: list(variable.shape) for name, variable in build.variables.items() + }, + } + + +def _canonical_structure(problem: cp.Problem) -> dict[str, Any]: + data, chain, _inverse = problem.get_problem_data( + cp.CLARABEL, canon_backend=cp.SCIPY_CANON_BACKEND + ) + dimensions = data["dims"] + matrix = data["A"] + quadratic = data.get("P") + return { + "backend": "SCIPY", + "canonical_variables": int(data["c"].shape[0]), + "equality_rows": int(dimensions.zero), + "nonnegative_rows": int(dimensions.nonneg), + "coefficient_rows": int(matrix.shape[0]), + "coefficient_columns": int(matrix.shape[1]), + "coefficient_nonzeros": int(matrix.nnz), + "quadratic_nonzeros": 0 if quadratic is None else int(quadratic.nnz), + "reductions": [type(item).__name__ for item in chain.reductions], + } + + +def _initialize(build: QualificationBuild) -> None: + for name, variable in build.variables.items(): + lower = ( + np.asarray(build.inputs[f"{name}_lower"], dtype=float) + if f"{name}_lower" in build.inputs + else None + ) + upper = ( + np.asarray(build.inputs[f"{name}_upper"], dtype=float) + if f"{name}_upper" in build.inputs + else None + ) + if lower is not None and upper is not None: + variable.value = np.broadcast_to( + (lower + upper) / 2.0, variable.shape + ).copy() + elif name == "theta": + variable.value = np.zeros(variable.shape) + elif name == "p_flows": + variable.value = np.zeros(variable.shape) + + +def _audit( + build: QualificationBuild, values: dict[str, np.ndarray] +) -> dict[str, float]: + pg = values["Pg"] + lower = np.broadcast_to(build.inputs["Pg_lower"], pg.shape) + upper = np.broadcast_to(build.inputs["Pg_upper"], pg.shape) + residuals = {"Pg_box_abs": float(max(0.0, np.max(lower - pg), np.max(pg - upper)))} + if build.formulation == "singlenode_dc": + residuals["active_balance_abs"] = float( + np.max(np.abs(np.sum(pg, axis=0) - np.sum(build.inputs["Pd"], axis=0))) + ) + elif build.formulation == "lossy_dc": + flow = values["p_flows"] + ppc, _ = reindex_case_to_consecutive(cast(dict[str, Any], case9())) + balance = ( + make_branch_node_incidence_matrix(ppc) @ flow + + build.inputs["Cg"] @ pg + - build.inputs["Pd"] + ) + residuals["active_balance_abs"] = float(np.max(np.abs(balance))) + residuals["flow_box_abs"] = float( + max( + 0.0, + np.max(build.inputs["p_flows_lower"] - flow), + np.max(flow - build.inputs["p_flows_upper"]), + ) + ) + else: + qg = values["Qg"] + voltage = values["v"] + residuals["Qg_box_abs"] = float( + max( + 0.0, + np.max(np.broadcast_to(build.inputs["Qg_lower"], qg.shape) - qg), + np.max(qg - np.broadcast_to(build.inputs["Qg_upper"], qg.shape)), + ) + ) + residuals["voltage_box_abs"] = float( + max( + 0.0, + np.max( + np.broadcast_to(build.inputs["v_lower"], voltage.shape) - voltage + ), + np.max( + voltage - np.broadcast_to(build.inputs["v_upper"], voltage.shape) + ), + ) + ) + theta = values["theta"] + conductance = np.asarray(build.inputs["G"], dtype=float) + susceptance = np.asarray(build.inputs["B"], dtype=float) + incidence = np.asarray(build.inputs["Cg"], dtype=float) + active_demand = np.asarray(build.inputs["Pd"], dtype=float) + reactive_demand = np.asarray(build.inputs["Qd"], dtype=float) + angle = theta[:, None, :] - theta[None, :, :] + voltage_product = voltage[:, None, :] * voltage[None, :, :] + active = np.sum( + voltage_product + * ( + conductance[:, :, None] * np.cos(angle) + + susceptance[:, :, None] * np.sin(angle) + ), + axis=1, + ) + reactive = np.sum( + voltage_product + * ( + conductance[:, :, None] * np.sin(angle) + - susceptance[:, :, None] * np.cos(angle) + ), + axis=1, + ) + residuals["active_balance_abs"] = float( + np.max(np.abs(active - (incidence @ pg - active_demand))) + ) + residuals["reactive_balance_abs"] = float( + np.max(np.abs(reactive - (incidence @ qg - reactive_demand))) + ) + residuals["reference_angle_abs"] = float(np.max(np.abs(theta[0, :]))) + return residuals + + +def _binding_probe(build: QualificationBuild) -> list[dict[str, Any]]: + """Drive both faces of every candidate box active under the same solver.""" + names = ["Pg"] + if build.formulation == "lossy_dc": + names.append("p_flows") + elif build.formulation == "ac": + names.extend(("Qg", "v")) + records = [] + for name in names: + lower = np.asarray(build.inputs[f"{name}_lower"], dtype=float) + upper = np.asarray(build.inputs[f"{name}_upper"], dtype=float) + variable, constraints = _variable( + name, + tuple(int(item) for item in lower.shape), + lower, + upper, + build.encoding, + ) + parity = np.indices(lower.shape).sum(axis=0) % 2 == 0 + desired = np.where(parity, lower, upper) + width = np.maximum(upper - lower, 1.0) + target = np.where(parity, lower - width, upper + width) + variable.value = (lower + upper) / 2.0 + probe = QualificationBuild( + build.formulation, + build.encoding, + "time_varying", + cp.Problem(cp.Minimize(cp.sum_squares(variable - target)), constraints), + {name: variable}, + {f"{name}_lower": lower, f"{name}_upper": upper}, + ) + exception = None + try: + probe.solve(convex_probe=True) + except Exception as error: + exception = f"{type(error).__name__}: {error}" + value = ( + None if variable.value is None else np.asarray(variable.value, dtype=float) + ) + face_residual = ( + None if value is None else float(np.max(np.abs(value - desired))) + ) + records.append( + { + "variable": name, + "status": probe.problem.status, + "solver": probe.problem.solver_stats.solver_name, + "canonicalization_backend": "SCIPY", + "exception": exception, + "lower_face_coordinates": int(np.count_nonzero(parity)), + "upper_face_coordinates": int(np.count_nonzero(~parity)), + "maximum_face_residual": face_residual, + "accepted": exception is None + and probe.problem.status in {cp.OPTIMAL, cp.OPTIMAL_INACCURATE} + and face_residual is not None + and face_residual <= AUDIT_TOLERANCE, + "values": None if value is None else value.tolist(), + } + ) + return records + + +def run_qualification( + formulation: Formulation, + encoding: BoundEncoding, + profile: BoundProfile, +) -> dict[str, Any]: + """Build, solve, extract, and independently audit one qualification arm.""" + started = time.perf_counter() + build = build_qualification(formulation, encoding, profile) + construction = time.perf_counter() - started + rss_after_construction = _peak_rss_bytes() + source = _source_structure(build) + canonical = None + canonicalization = None + if formulation != "ac": + started = time.perf_counter() + canonical = _canonical_structure(build.problem) + canonicalization = time.perf_counter() - started + rss_after_canonicalization = _peak_rss_bytes() + _initialize(build) + started = time.perf_counter() + exception = None + try: + build.solve() + except Exception as error: # retain formulation-local solver behavior + exception = f"{type(error).__name__}: {error}" + solve = time.perf_counter() - started + rss_after_solve = _peak_rss_bytes() + complete_values = all( + variable.value is not None for variable in build.variables.values() + ) + values = ( + { + name: np.asarray(variable.value, dtype=float) + for name, variable in build.variables.items() + } + if complete_values + else {} + ) + finite_values = bool(values) and all( + np.isfinite(value).all() for value in values.values() + ) + residuals = _audit(build, values) if finite_values else {} + stats = build.problem.solver_stats + objective = build.problem.value + finite_objective = objective is not None and np.isfinite(float(objective)) + accepted = ( + exception is None + and build.problem.status in {cp.OPTIMAL, cp.OPTIMAL_INACCURATE} + and finite_values + and finite_objective + and bool(residuals) + and max(residuals.values()) <= AUDIT_TOLERANCE + ) + binding_probes = _binding_probe(build) + return { + "formulation": formulation, + "encoding": encoding, + "profile": profile, + "status": build.problem.status, + "accepted": accepted, + "exception": exception, + "objective": float(objective) if finite_objective else None, + "values": {name: value.tolist() for name, value in values.items()}, + "residuals": residuals, + "binding_probes": binding_probes, + "source_structure": source, + "canonical_structure": canonical, + "timing_seconds": { + "construction": construction, + "canonicalization": canonicalization, + "solve": solve, + }, + "process_peak_rss_bytes": { + "after_construction": rss_after_construction, + "after_canonicalization": rss_after_canonicalization, + "after_solve": rss_after_solve, + }, + "solver": stats.solver_name, + "solver_iterations": stats.num_iters, + "solve_time": stats.solve_time, + } + + +def compare_pair(explicit: dict[str, Any], leaf: dict[str, Any]) -> dict[str, Any]: + """Compare one formulation/profile pair without cross-formulation inference.""" + if (explicit["formulation"], explicit["profile"]) != ( + leaf["formulation"], + leaf["profile"], + ): + raise ValueError("qualification pair identity mismatch") + names = set(explicit["values"]) + schemas_match = names == set(leaf["values"]) + value_residuals = { + name: float( + np.max( + np.abs( + np.asarray(explicit["values"][name], dtype=float) + - np.asarray(leaf["values"][name], dtype=float) + ) + ) + ) + for name in sorted(names.intersection(leaf["values"])) + } + objective_residual = ( + None + if explicit["objective"] is None or leaf["objective"] is None + else abs(float(explicit["objective"]) - float(leaf["objective"])) + ) + accepted = bool(explicit["accepted"] and leaf["accepted"]) + explicit_probes = {probe["variable"]: probe for probe in explicit["binding_probes"]} + leaf_probes = {probe["variable"]: probe for probe in leaf["binding_probes"]} + probe_schemas_match = set(explicit_probes) == set(leaf_probes) + probe_value_residuals = { + name: float( + np.max( + np.abs( + np.asarray(explicit_probes[name]["values"], dtype=float) + - np.asarray(leaf_probes[name]["values"], dtype=float) + ) + ) + ) + for name in sorted(set(explicit_probes).intersection(leaf_probes)) + if explicit_probes[name]["values"] is not None + and leaf_probes[name]["values"] is not None + } + binding_probes_passed = ( + probe_schemas_match + and all(probe["accepted"] for probe in explicit_probes.values()) + and all(probe["accepted"] for probe in leaf_probes.values()) + and len(probe_value_residuals) == len(explicit_probes) + and max(probe_value_residuals.values(), default=0.0) <= PAIR_ABSOLUTE_TOLERANCE + ) + gated_value_names = ("Pg",) + equivalent = ( + accepted + and schemas_match + and binding_probes_passed + and objective_residual is not None + and objective_residual <= PAIR_ABSOLUTE_TOLERANCE + and max((value_residuals[name] for name in gated_value_names), default=0.0) + <= PAIR_ABSOLUTE_TOLERANCE + ) + return { + "formulation": explicit["formulation"], + "profile": explicit["profile"], + "both_accepted": accepted, + "result_schemas_match": schemas_match, + "binding_probes_passed": binding_probes_passed, + "binding_probe_value_absolute_residuals": probe_value_residuals, + "equivalent": equivalent, + "objective_absolute_residual": objective_residual, + "gated_value_names": list(gated_value_names), + "value_absolute_residuals": value_residuals, + "explicit": explicit, + "leaf": leaf, + } + + +def formulation_decision( + formulation: Formulation, pairs: list[dict[str, Any]] +) -> dict[str, Any]: + """Apply the formulation-local qualification rule.""" + isolated_passed = all(pair["equivalent"] for pair in pairs) + production_qualified = isolated_passed and formulation != "ac" + candidate_boxes = { + "ac": ["Pg", "Qg", "v"], + "lossy_dc": ["Pg", "p_flows"], + "singlenode_dc": ["Pg"], + }[formulation] + return { + "isolated_leaf_compatibility_passed": isolated_passed, + "leaf_bounds_qualified": production_qualified, + "selected_representation": "leaf" if production_qualified else "explicit", + "qualified_variable_boxes": candidate_boxes if production_qualified else [], + "isolated_candidate_boxes": candidate_boxes, + "profiles": list(BOUND_PROFILES), + "reason": ( + "both frozen profiles and binding probes passed" + if production_qualified + else ( + "isolated AC compatibility passed, but the production lifted " + "DNLP and terminal-policy risk remains; retain explicit inequalities" + if isolated_passed and formulation == "ac" + else "a paired gate regressed; retain explicit inequalities" + ) + ), + } + + +def run_all() -> dict[str, Any]: + """Run the complete frozen matrix and decide each formulation separately.""" + pairs = [] + decisions: dict[str, dict[str, Any]] = {} + for formulation in FORMULATIONS: + formulation_pairs = [] + for profile in BOUND_PROFILES: + pair = compare_pair( + run_qualification(formulation, "explicit", profile), + run_qualification(formulation, "leaf", profile), + ) + pairs.append(pair) + formulation_pairs.append(pair) + decisions[formulation] = formulation_decision(formulation, formulation_pairs) + return { + "schema_version": 1, + "stage": "M14a.1_leaf_bound_qualification", + "horizon": HORIZON, + "audit_tolerance": AUDIT_TOLERANCE, + "pair_absolute_tolerance": PAIR_ABSOLUTE_TOLERANCE, + "decisions": decisions, + "pairs": pairs, + "cross_formulation_inference_permitted": False, + } diff --git a/experiments/m14_time_vectorization/run_m14a1.py b/experiments/m14_time_vectorization/run_m14a1.py new file mode 100644 index 0000000..a42fe46 --- /dev/null +++ b/experiments/m14_time_vectorization/run_m14a1.py @@ -0,0 +1,212 @@ +"""Run and retain the isolated M14a.1 leaf-bound qualification matrix.""" + +from __future__ import annotations + +import argparse +import hashlib +from importlib.metadata import PackageNotFoundError, version +import json +import os +from pathlib import Path +import platform +import subprocess +import sys +import tempfile +from typing import Any, cast + +from experiments.m14_time_vectorization.m14a1_bounds import ( + BOUND_PROFILES, + FORMULATIONS, + BoundEncoding, + BoundProfile, + Formulation, + compare_pair, + formulation_decision, + run_qualification, +) + + +ROOT = Path(__file__).resolve().parents[2] +RESULT_PATH = ROOT / "experiments/m14_time_vectorization/M14A1_RESULTS.json" + + +def _git(*arguments: str) -> str | None: + result = subprocess.run( + ["git", *arguments], cwd=ROOT, check=False, capture_output=True, text=True + ) + return result.stdout.strip() if result.returncode == 0 else None + + +def _source_fingerprint() -> str: + paths = sorted((ROOT / "src/cvxopf").rglob("*.py")) + sorted( + (ROOT / "experiments/m14_time_vectorization").rglob("*.py") + ) + digest = hashlib.sha256() + for path in paths: + digest.update(path.relative_to(ROOT).as_posix().encode()) + digest.update(b"\0") + digest.update(path.read_bytes()) + digest.update(b"\0") + return digest.hexdigest() + + +def _package_version(name: str) -> str | None: + try: + return version(name) + except PackageNotFoundError: + return None + + +def execution_context() -> dict[str, Any]: + try: + from cyipopt import IPOPT_VERSION + except ImportError: + ipopt = None + else: + ipopt = ".".join(str(item) for item in IPOPT_VERSION) + return { + "git_commit": _git("rev-parse", "HEAD"), + "worktree_clean": _git("status", "--porcelain") == "", + "source_fingerprint": _source_fingerprint(), + "platform": platform.platform(), + "machine": platform.machine(), + "python": platform.python_version(), + "packages": { + name: _package_version(name) + for name in ("cvxpy", "clarabel", "cyipopt", "numpy", "scipy") + } + | {"ipopt": ipopt}, + } + + +def build_result() -> dict[str, Any]: + """Execute the matrix under stable source provenance.""" + before = execution_context() + if before["worktree_clean"] is not True: + raise RuntimeError("authoritative M14a.1 execution requires a clean worktree") + pairs = [] + decisions: dict[str, dict[str, Any]] = {} + with tempfile.TemporaryDirectory(prefix="cvxopf-m14a1-") as temporary: + directory = Path(temporary) + for formulation in FORMULATIONS: + formulation_pairs = [] + for profile in BOUND_PROFILES: + arms = { + encoding: _run_worker( + formulation, + encoding, + profile, + directory / f"{formulation}-{profile}-{encoding}.json", + before, + ) + for encoding in ("explicit", "leaf") + } + pair = compare_pair(arms["explicit"], arms["leaf"]) + pairs.append(pair) + formulation_pairs.append(pair) + decisions[formulation] = formulation_decision( + formulation, formulation_pairs + ) + result = { + "schema_version": 1, + "stage": "M14a.1_leaf_bound_qualification", + "horizon": 3, + "audit_tolerance": 1e-6, + "pair_absolute_tolerance": 2e-4, + "fresh_process_per_arm": True, + "cross_formulation_inference_permitted": False, + "decisions": decisions, + "pairs": pairs, + } + after = execution_context() + if ( + after["git_commit"] != before["git_commit"] + or after["source_fingerprint"] != before["source_fingerprint"] + ): + raise RuntimeError("M14a.1 execution source changed during the run") + if after["worktree_clean"] is not True: + raise RuntimeError("M14a.1 worktree changed during the run") + return {**result, "execution_context": after} + + +def _run_worker( + formulation: Formulation, + encoding: BoundEncoding, + profile: BoundProfile, + output: Path, + expected_context: dict[str, Any], +) -> dict[str, Any]: + command = [ + sys.executable, + "-m", + "experiments.m14_time_vectorization.run_m14a1", + "--worker", + "--formulation", + formulation, + "--encoding", + encoding, + "--profile", + profile, + "--output", + str(output), + ] + completed = subprocess.run( + command, cwd=ROOT, check=False, capture_output=True, text=True + ) + if completed.returncode != 0: + raise RuntimeError( + f"M14a.1 worker failed for {formulation}/{profile}/{encoding}: " + f"{completed.stderr[-2000:]}" + ) + payload = cast(dict[str, Any], json.loads(output.read_text())) + context = payload.pop("execution_context") + for name in ("git_commit", "source_fingerprint"): + if context.get(name) != expected_context.get(name): + raise RuntimeError(f"M14a.1 worker {name} mismatch") + if context.get("worktree_clean") is not True: + raise RuntimeError("M14a.1 worker observed a dirty worktree") + return payload + + +def write_immutable(path: Path, value: object) -> None: + data = ( + json.dumps(value, sort_keys=True, indent=2, allow_nan=False) + "\n" + ).encode() + path.parent.mkdir(parents=True, exist_ok=True) + descriptor = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o644) + with os.fdopen(descriptor, "wb") as stream: + stream.write(data) + stream.flush() + os.fsync(stream.fileno()) + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--output", type=Path, default=RESULT_PATH) + parser.add_argument("--worker", action="store_true") + parser.add_argument("--formulation", choices=FORMULATIONS) + parser.add_argument("--encoding", choices=("explicit", "leaf")) + parser.add_argument("--profile", choices=BOUND_PROFILES) + arguments = parser.parse_args() + if arguments.worker: + if ( + arguments.formulation is None + or arguments.encoding is None + or arguments.profile is None + ): + parser.error("worker mode requires formulation, encoding, and profile") + worker_result = run_qualification( + arguments.formulation, arguments.encoding, arguments.profile + ) + write_immutable( + arguments.output.resolve(), + {**worker_result, "execution_context": execution_context()}, + ) + return + result = build_result() + write_immutable(arguments.output.resolve(), result) + print(json.dumps(result["decisions"], sort_keys=True, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/tests/test_m14a1_bounds.py b/tests/test_m14a1_bounds.py new file mode 100644 index 0000000..3cd34d9 --- /dev/null +++ b/tests/test_m14a1_bounds.py @@ -0,0 +1,117 @@ +"""Focused M14a.1 formulation-separated leaf-bound qualification tests.""" + +from copy import deepcopy +from pathlib import Path + +import numpy as np +import pytest + +from experiments.m14_time_vectorization.m14a1_bounds import ( + BOUND_PROFILES, + FORMULATIONS, + HORIZON, + build_qualification, + compare_pair, + run_all, + run_qualification, +) +from experiments.m14_time_vectorization.run_m14a1 import write_immutable + + +@pytest.mark.parametrize("formulation", FORMULATIONS) +@pytest.mark.parametrize("profile", BOUND_PROFILES) +def test_leaf_and_explicit_models_have_identical_time_last_variables( + formulation, profile +): + explicit = build_qualification(formulation, "explicit", profile) + leaf = build_qualification(formulation, "leaf", profile) + + assert {name: value.shape for name, value in explicit.variables.items()} == { + name: value.shape for name, value in leaf.variables.items() + } + assert all(value.shape[-1] == HORIZON for value in leaf.variables.values()) + assert len(explicit.problem.constraints) > len(leaf.problem.constraints) + + +def test_static_bounds_are_broadcast_views_and_dynamic_bounds_are_materialized(): + static = build_qualification("ac", "leaf", "static") + dynamic = build_qualification("ac", "leaf", "time_varying") + + assert np.asarray(static.inputs["Pg_lower"]).flags.owndata is False + assert np.asarray(static.inputs["Pg_upper"]).flags.owndata is False + assert np.asarray(dynamic.inputs["Pg_lower"]).flags.owndata is True + assert np.asarray(dynamic.inputs["Pg_upper"]).flags.owndata is True + + +@pytest.mark.parametrize("formulation", FORMULATIONS) +@pytest.mark.parametrize("profile", BOUND_PROFILES) +def test_each_formulation_passes_its_own_paired_solver_gate(formulation, profile): + explicit = run_qualification(formulation, "explicit", profile) + leaf = run_qualification(formulation, "leaf", profile) + pair = compare_pair(explicit, leaf) + + assert pair["both_accepted"] is True + assert pair["equivalent"] is True + assert pair["binding_probes_passed"] is True + assert all( + probe["accepted"] + and probe["solver"] == "CLARABEL" + and probe["canonicalization_backend"] == "SCIPY" + and probe["lower_face_coordinates"] > 0 + and probe["upper_face_coordinates"] > 0 + for arm in (explicit, leaf) + for probe in arm["binding_probes"] + ) + assert explicit["source_structure"]["explicit_inequality_objects"] > 0 + assert leaf["source_structure"]["explicit_inequality_objects"] == 0 + if formulation == "ac": + assert explicit["canonical_structure"] is None + assert leaf["canonical_structure"] is None + assert explicit["solver"] == "IPOPT" + assert leaf["solver"] == "IPOPT" + else: + assert explicit["canonical_structure"]["backend"] == "SCIPY" + assert leaf["canonical_structure"]["backend"] == "SCIPY" + + +def test_consolidated_decisions_are_formulation_local(): + result = run_all() + + assert result["cross_formulation_inference_permitted"] is False + assert set(result["decisions"]) == set(FORMULATIONS) + assert len(result["pairs"]) == 6 + assert result["decisions"]["lossy_dc"]["leaf_bounds_qualified"] is True + assert result["decisions"]["singlenode_dc"]["leaf_bounds_qualified"] is True + assert result["decisions"]["ac"]["isolated_leaf_compatibility_passed"] is True + assert result["decisions"]["ac"]["leaf_bounds_qualified"] is False + assert result["decisions"]["ac"]["selected_representation"] == "explicit" + + +def test_ac_audit_reports_independently_reconstructed_physical_channels(): + result = run_qualification("ac", "explicit", "static") + + assert "equality_abs" not in result["residuals"] + assert set(result["residuals"]) >= { + "active_balance_abs", + "reactive_balance_abs", + "reference_angle_abs", + } + + +def test_nongated_ac_coordinates_are_retained_without_forcing_uniqueness(): + explicit = run_qualification("ac", "explicit", "static") + leaf = deepcopy(run_qualification("ac", "leaf", "static")) + leaf["values"]["Qg"][0][0] += 1e-3 + + pair = compare_pair(explicit, leaf) + + assert pair["value_absolute_residuals"]["Qg"] >= 9e-4 + assert pair["gated_value_names"] == ["Pg"] + assert pair["equivalent"] is True + + +def test_immutable_result_writer_refuses_replacement(tmp_path: Path): + path = tmp_path / "result.json" + write_immutable(path, {"value": 1}) + with pytest.raises(FileExistsError): + write_immutable(path, {"value": 2}) From 1f45651fa8450cdfc50e55dd024eb1fbcc4b7c06 Mon Sep 17 00:00:00 2001 From: Bennet Meyers Date: Thu, 27 Aug 2026 15:51:18 -0700 Subject: [PATCH 18/28] docs: point Codex agents to repository guidance Add the standard AGENTS.md discovery file as a short pointer to the authoritative CLAUDE.md guide, avoiding duplicated instructions that could drift. --- AGENTS.md | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 AGENTS.md diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000..d32183d --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,4 @@ +# Codex agent instructions + +Read and follow [`CLAUDE.md`](CLAUDE.md) before making changes in this +repository. It is the authoritative developer guide for all AI coding agents. From e3ec74fa1b39604c76a21ef1e52ca6fde556ff83 Mon Sep 17 00:00:00 2001 From: Bennet Meyers Date: Thu, 27 Aug 2026 15:56:16 -0700 Subject: [PATCH 19/28] results(m14a): record leaf-bound qualification Promote the authoritative fresh-process M14a.1 result and record its formulation-specific decisions. Lossy DC and single-node DC select their qualified leaf boxes, while AC retains explicit inequalities pending production-structure evidence. --- CLAUDE.md | 2 +- .../m14_time_vectorization/M14A1_RESULTS.json | 2713 +++++++++++++++++ plans/milestone-14-time-vectorization.md | 15 +- 3 files changed, 2726 insertions(+), 4 deletions(-) create mode 100644 experiments/m14_time_vectorization/M14A1_RESULTS.json diff --git a/CLAUDE.md b/CLAUDE.md index 0b2c127..49f760b 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -737,7 +737,7 @@ is present. | 11 — SOCP (convex) network model | 🔲 Future | | | 12 — Extend battery parameters: final SoC, penalty vs constraint | ✅ Complete | Storage-owned terminal equality or zero-shortfall constraints and linear/quadratic, one-/two-sided terminal costs, consistently composed across formulations. See `plans/milestone-12-storage-terminal-soc.md`. | | 13 — Extend CVXPY parameterization for problem data | 🔲 Future | Faster repeated solves of the same graph over new data | -| 14 — Time-vectorized multistep formulations | 🟧 In progress / blocking | M14a's frozen legacy Case9 and Case118 scaling baseline is complete and authorizes M14b. Next, add the explicit time-last tensor assembly mode using SCIPY canonicalization alongside the retained stepwise/CPP path, preserving formulation, failure, audit, and result contracts. Vectorized lossy DC remains the first delivery and blocks resumption of the Case118 annual S4 outer solve after macOS killed the repeated annual graph under extreme compressed-memory pressure. See `plans/milestone-14-time-vectorization.md`. | +| 14 — Time-vectorized multistep formulations | 🟧 In progress / blocking | M14a's frozen legacy baseline and M14a.1's formulation-specific leaf-bound qualification are complete and authorize M14b. Lossy DC and single-node DC may use their qualified leaf boxes; AC retains explicit inequalities. Next, add the explicit time-last tensor assembly mode using SCIPY canonicalization alongside the retained stepwise/CPP path, preserving formulation, failure, audit, and result contracts. Vectorized lossy DC remains the first delivery and blocks resumption of the Case118 annual S4 outer solve after macOS killed the repeated annual graph under extreme compressed-memory pressure. See `plans/milestone-14-time-vectorization.md`. | | 15 — Full lossy HVDC (sign-switching converter losses) | 🔲 Future | charge/discharge-style split of `p_in`; adds fixed converter loss (`LOSS0`); enables losses in `free` and zero-straddling `band` steps; reactive-power support proposed. See `plans/milestone-15-full-lossy-hvdc.md`. | | 16 — Unify grid component model patterns | ✅ Complete | Generators, storage, nondispatchable units, and HVDC share formulation-specific injection and operating-set APIs, temporal coupling slots, and device-owned cost boundaries. Includes first-class `DispatchableGenerator`, MATPOWER fallback, stable identity for external ND/HVDC tables, and collapsed singlenode reuse. See `plans/milestone-16-unify-components.md` and `memories/M16-in-flight-record.md`. | | 17 — Hierarchical DC→AC receding-horizon dispatch | ✅ Complete | The capstone controller passes **identity-aligned SoC signposts only** (not other setpoints) from long-horizon `lossy_dc` planning into short AC-OPF windows, executes only residual-checked target-conditioned first actions, supports causal shifted initialization with audited recovery, and retains the complete plan/attempt tree. M17 fixes the validated `lossy_dc`→`ac` workflow; configurable formulations and additional layers are M21. See `plans/milestone-17-hierarchical-dc-ac.md`. | diff --git a/experiments/m14_time_vectorization/M14A1_RESULTS.json b/experiments/m14_time_vectorization/M14A1_RESULTS.json new file mode 100644 index 0000000..a9739f5 --- /dev/null +++ b/experiments/m14_time_vectorization/M14A1_RESULTS.json @@ -0,0 +1,2713 @@ +{ + "audit_tolerance": 1e-06, + "cross_formulation_inference_permitted": false, + "decisions": { + "ac": { + "isolated_candidate_boxes": [ + "Pg", + "Qg", + "v" + ], + "isolated_leaf_compatibility_passed": true, + "leaf_bounds_qualified": false, + "profiles": [ + "static", + "time_varying" + ], + "qualified_variable_boxes": [], + "reason": "isolated AC compatibility passed, but the production lifted DNLP and terminal-policy risk remains; retain explicit inequalities", + "selected_representation": "explicit" + }, + "lossy_dc": { + "isolated_candidate_boxes": [ + "Pg", + "p_flows" + ], + "isolated_leaf_compatibility_passed": true, + "leaf_bounds_qualified": true, + "profiles": [ + "static", + "time_varying" + ], + "qualified_variable_boxes": [ + "Pg", + "p_flows" + ], + "reason": "both frozen profiles and binding probes passed", + "selected_representation": "leaf" + }, + "singlenode_dc": { + "isolated_candidate_boxes": [ + "Pg" + ], + "isolated_leaf_compatibility_passed": true, + "leaf_bounds_qualified": true, + "profiles": [ + "static", + "time_varying" + ], + "qualified_variable_boxes": [ + "Pg" + ], + "reason": "both frozen profiles and binding probes passed", + "selected_representation": "leaf" + } + }, + "execution_context": { + "git_commit": "1f45651fa8450cdfc50e55dd024eb1fbcc4b7c06", + "machine": "arm64", + "packages": { + "clarabel": "0.11.1", + "cvxpy": "1.9.2", + "cyipopt": "1.7.0", + "ipopt": "3.14.19", + "numpy": "2.4.6", + "scipy": "1.17.1" + }, + "platform": "macOS-26.5.2-arm64-arm-64bit", + "python": "3.11.15", + "source_fingerprint": "cd0852da768b18ba367845131f9fe25023687cbd7dc708908ee9656555f63174", + "worktree_clean": true + }, + "fresh_process_per_arm": true, + "horizon": 3, + "pair_absolute_tolerance": 0.0002, + "pairs": [ + { + "binding_probe_value_absolute_residuals": { + "Pg": 5.235856193053223e-11, + "Qg": 0.0, + "v": 0.0 + }, + "binding_probes_passed": true, + "both_accepted": true, + "equivalent": true, + "explicit": { + "accepted": true, + "binding_probes": [ + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "lower_face_coordinates": 5, + "maximum_face_residual": 4.924105567738479e-10, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 4, + "values": [ + [ + 0.10000000049241017, + 2.4999999995075894, + 0.10000000049241017 + ], + [ + 3.0000000000523586, + 0.09999999994764175, + 3.0000000000523586 + ], + [ + 0.10000000017026256, + 2.699999999829738, + 0.10000000017026256 + ] + ], + "variable": "Pg" + }, + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "lower_face_coordinates": 5, + "maximum_face_residual": 3.861587494213836e-09, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 4, + "values": [ + [ + -2.9999999961384125, + 2.9999999961384125, + -2.9999999961384125 + ], + [ + 2.9999999961384125, + -2.9999999961384125, + 2.9999999961384125 + ], + [ + -2.9999999961384125, + 2.9999999961384125, + -2.9999999961384125 + ] + ], + "variable": "Qg" + }, + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "lower_face_coordinates": 14, + "maximum_face_residual": 3.130309345067417e-10, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 13, + "values": [ + [ + 0.9000000003130306, + 1.0999999996869692, + 0.9000000003130306 + ], + [ + 1.0999999996869692, + 0.9000000003130306, + 1.0999999996869692 + ], + [ + 0.9000000003130306, + 1.0999999996869692, + 0.9000000003130306 + ], + [ + 1.0999999996869692, + 0.9000000003130306, + 1.0999999996869692 + ], + [ + 0.9000000003130306, + 1.0999999996869692, + 0.9000000003130306 + ], + [ + 1.0999999996869692, + 0.9000000003130306, + 1.0999999996869692 + ], + [ + 0.9000000003130306, + 1.0999999996869692, + 0.9000000003130306 + ], + [ + 1.0999999996869692, + 0.9000000003130306, + 1.0999999996869692 + ], + [ + 0.9000000003130306, + 1.0999999996869692, + 0.9000000003130306 + ] + ], + "variable": "v" + } + ], + "canonical_structure": null, + "encoding": "explicit", + "exception": null, + "formulation": "ac", + "objective": 15890.791098191045, + "process_peak_rss_bytes": { + "after_canonicalization": 144932864, + "after_construction": 144932864, + "after_solve": 150601728 + }, + "profile": "static", + "residuals": { + "Pg_box_abs": 0.0, + "Qg_box_abs": 0.0, + "active_balance_abs": 1.4513279467109896e-11, + "reactive_balance_abs": 4.507783035734292e-11, + "reference_angle_abs": 1.012068894242113e-29, + "voltage_box_abs": 0.0 + }, + "solve_time": null, + "solver": "IPOPT", + "solver_iterations": "Not available", + "source_structure": { + "constraint_objects": 13, + "equality_objects": 7, + "explicit_inequality_objects": 6, + "explicit_scalar_inequalities": 90, + "scalar_equalities": 57, + "scalar_variables": 72, + "variable_objects": 4, + "variable_shapes": { + "Pg": [ + 3, + 3 + ], + "Qg": [ + 3, + 3 + ], + "theta": [ + 9, + 3 + ], + "v": [ + 9, + 3 + ] + } + }, + "status": "optimal", + "timing_seconds": { + "canonicalization": null, + "construction": 0.002989750006236136, + "solve": 0.016610542021226138 + }, + "values": { + "Pg": [ + [ + 0.8875316255779158, + 0.8979870779320545, + 0.9084486136863995 + ], + [ + 1.330418512708649, + 1.3432060071144087, + 1.3559943011910323 + ], + [ + 0.9329645840487785, + 0.9418738038962532, + 0.9507840116025592 + ] + ], + "Qg": [ + [ + 0.12320587007458783, + 0.12965647339325787, + 0.13613289579626445 + ], + [ + -0.007557495729382415, + 0.00031844052596947725, + 0.008237165810241358 + ], + [ + -0.23142854711477348, + -0.22634207062148518, + -0.22123176708500528 + ] + ], + "theta": [ + [ + -1.012068894242113e-29, + -5.530384514195347e-31, + 1.5060333492314387e-32 + ], + [ + 0.08488201706252577, + 0.08541019926288745, + 0.08593699033437575 + ], + [ + 0.056448027974316715, + 0.056715201263997206, + 0.05698131402346283 + ], + [ + -0.04247313647324778, + -0.04298613443744166, + -0.043499771984098545 + ], + [ + -0.0686657454072567, + -0.06949870310008596, + -0.07033299891499636 + ], + [ + 0.010681697237103193, + 0.010522400804584747, + 0.010362229450561474 + ], + [ + -0.020406087044459776, + -0.020878886729077638, + -0.0213527030298756 + ], + [ + 0.015916608564713552, + 0.015806281131006718, + 0.015695067080513943 + ], + [ + -0.07958164622924797, + -0.0805511099274972, + -0.08152231398180827 + ] + ], + "v": [ + [ + 1.099999993925647, + 1.099999999925007, + 1.0999999999669754 + ], + [ + 1.0969545161742504, + 1.0973546244318508, + 1.0977564325960214 + ], + [ + 1.0863646209478441, + 1.086620303124688, + 1.0868769598794799 + ], + [ + 1.0945355913234431, + 1.0942215153384558, + 1.0939063846537853 + ], + [ + 1.0849683484031967, + 1.08444849443034, + 1.0839273672586054 + ], + [ + 1.099999999995359, + 1.0999999999953303, + 1.0999999999953922 + ], + [ + 1.0896876354443683, + 1.089489484070816, + 1.0892911264447844 + ], + [ + 1.099999999995447, + 1.0999999999954577, + 1.0999999999955363 + ], + [ + 1.07239700606234, + 1.071755447277405, + 1.0711121856056183 + ] + ] + } + }, + "formulation": "ac", + "gated_value_names": [ + "Pg" + ], + "leaf": { + "accepted": true, + "binding_probes": [ + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "lower_face_coordinates": 5, + "maximum_face_residual": 4.924102098291527e-10, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 4, + "values": [ + [ + 0.10000000049241022, + 2.49999999950759, + 0.10000000049241022 + ], + [ + 3.0, + 0.1, + 3.0 + ], + [ + 0.10000000017026259, + 2.699999999829738, + 0.10000000017026259 + ] + ], + "variable": "Pg" + }, + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "lower_face_coordinates": 5, + "maximum_face_residual": 3.861587494213836e-09, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 4, + "values": [ + [ + -2.9999999961384125, + 2.9999999961384125, + -2.9999999961384125 + ], + [ + 2.9999999961384125, + -2.9999999961384125, + 2.9999999961384125 + ], + [ + -2.9999999961384125, + 2.9999999961384125, + -2.9999999961384125 + ] + ], + "variable": "Qg" + }, + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "lower_face_coordinates": 14, + "maximum_face_residual": 3.130309345067417e-10, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 13, + "values": [ + [ + 0.9000000003130306, + 1.0999999996869692, + 0.9000000003130306 + ], + [ + 1.0999999996869692, + 0.9000000003130306, + 1.0999999996869692 + ], + [ + 0.9000000003130306, + 1.0999999996869692, + 0.9000000003130306 + ], + [ + 1.0999999996869692, + 0.9000000003130306, + 1.0999999996869692 + ], + [ + 0.9000000003130306, + 1.0999999996869692, + 0.9000000003130306 + ], + [ + 1.0999999996869692, + 0.9000000003130306, + 1.0999999996869692 + ], + [ + 0.9000000003130306, + 1.0999999996869692, + 0.9000000003130306 + ], + [ + 1.0999999996869692, + 0.9000000003130306, + 1.0999999996869692 + ], + [ + 0.9000000003130306, + 1.0999999996869692, + 0.9000000003130306 + ] + ], + "variable": "v" + } + ], + "canonical_structure": null, + "encoding": "leaf", + "exception": null, + "formulation": "ac", + "objective": 15890.791098213462, + "process_peak_rss_bytes": { + "after_canonicalization": 144785408, + "after_construction": 144785408, + "after_solve": 150568960 + }, + "profile": "static", + "residuals": { + "Pg_box_abs": 0.0, + "Qg_box_abs": 0.0, + "active_balance_abs": 3.3474778504682945e-11, + "reactive_balance_abs": 1.0397693817054687e-10, + "reference_angle_abs": 3.2395472864516705e-35, + "voltage_box_abs": 0.0 + }, + "solve_time": null, + "solver": "IPOPT", + "solver_iterations": "Not available", + "source_structure": { + "constraint_objects": 7, + "equality_objects": 7, + "explicit_inequality_objects": 0, + "explicit_scalar_inequalities": 0, + "scalar_equalities": 57, + "scalar_variables": 72, + "variable_objects": 4, + "variable_shapes": { + "Pg": [ + 3, + 3 + ], + "Qg": [ + 3, + 3 + ], + "theta": [ + 9, + 3 + ], + "v": [ + 9, + 3 + ] + } + }, + "status": "optimal", + "timing_seconds": { + "canonicalization": null, + "construction": 0.0028100420022383332, + "solve": 0.01718337496276945 + }, + "values": { + "Pg": [ + [ + 0.8875316254226935, + 0.8979870779303739, + 0.9084486136863748 + ], + [ + 1.3304185127902541, + 1.3432060071153142, + 1.3559943011910445 + ], + [ + 0.9329645841361346, + 0.941873803897216, + 0.9507840116025728 + ] + ], + "Qg": [ + [ + 0.12320582640892075, + 0.1296564729233059, + 0.13613289578962057 + ], + [ + -0.007557470273297499, + 0.000318440799980813, + 0.008237165814115974 + ], + [ + -0.2314285238392963, + -0.22634207037097748, + -0.22123176708149156 + ] + ], + "theta": [ + [ + 3.902618470714155e-37, + 3.2395472864516705e-35, + 5.882141651308723e-38 + ], + [ + 0.08488201554002174, + 0.08541019924643221, + 0.08593699033414154 + ], + [ + 0.05644802645082918, + 0.05671520124753629, + 0.05698131402322963 + ], + [ + -0.04247313698311744, + -0.04298613444298644, + -0.04349977198417724 + ], + [ + -0.06866574642461375, + -0.06949870311111807, + -0.07033299891515263 + ], + [ + 0.010681695763016115, + 0.010522400788661419, + 0.01036222945033616 + ], + [ + -0.020406088495677464, + -0.020878886744754348, + -0.02135270303009746 + ], + [ + 0.0159166071298206, + 0.01580628111550387, + 0.01569506708029405 + ], + [ + -0.07958164727836159, + -0.08055110993888281, + -0.0815223139819696 + ] + ], + "v": [ + [ + 1.0999999861049712, + 1.0999999998409271, + 1.0999999999657935 + ], + [ + 1.0969545176323607, + 1.0973546244475558, + 1.097756432596249 + ], + [ + 1.0863646222209353, + 1.0866203031384076, + 1.0868769598796755 + ], + [ + 1.0945355857589856, + 1.094221515278623, + 1.0939063846529458 + ], + [ + 1.0849683446473104, + 1.0844484943899506, + 1.0839273672580394 + ], + [ + 1.099999999995536, + 1.0999999999953547, + 1.0999999999953955 + ], + [ + 1.0896876354444718, + 1.089489484070838, + 1.0892911264447893 + ], + [ + 1.099999999995587, + 1.0999999999954782, + 1.0999999999955419 + ], + [ + 1.072397002244062, + 1.0717554472363373, + 1.071112185605044 + ] + ] + } + }, + "objective_absolute_residual": 2.2417225409299135e-08, + "profile": "static", + "result_schemas_match": true, + "value_absolute_residuals": { + "Pg": 1.5522227947428746e-10, + "Qg": 4.3665667082137816e-08, + "theta": 1.5234875375136347e-09, + "v": 7.820675884673278e-09 + } + }, + { + "binding_probe_value_absolute_residuals": { + "Pg": 6.125899787434719e-11, + "Qg": 8.881784197001252e-16, + "v": 4.440892098500626e-16 + }, + "binding_probes_passed": true, + "both_accepted": true, + "equivalent": true, + "explicit": { + "accepted": true, + "binding_probes": [ + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "lower_face_coordinates": 5, + "maximum_face_residual": 4.937633635293537e-10, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 4, + "values": [ + [ + 0.10000000047279625, + 2.497599999516803, + 0.10480000049376337 + ], + [ + 3.000000000061259, + 0.10289999994127123, + 2.9942000000561477 + ], + [ + 0.10000000015702297, + 2.6973999998370792, + 0.10520000016891555 + ] + ], + "variable": "Pg" + }, + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "lower_face_coordinates": 5, + "maximum_face_residual": 3.832200778930428e-09, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 4, + "values": [ + [ + -2.99999999623865, + 2.9939999962035158, + -2.987999996167799 + ], + [ + 2.99999999623865, + -2.9939999962035158, + 2.987999996167799 + ], + [ + -2.99999999623865, + 2.9939999962035158, + -2.987999996167799 + ] + ], + "variable": "Qg" + }, + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "lower_face_coordinates": 14, + "maximum_face_residual": 3.1602187533508186e-10, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 13, + "values": [ + [ + 0.9000000003160219, + 1.099799999684074, + 0.900400000315831 + ], + [ + 1.0999999996839784, + 0.9002000003159262, + 1.099599999684169 + ], + [ + 0.9000000003160219, + 1.099799999684074, + 0.900400000315831 + ], + [ + 1.0999999996839784, + 0.9002000003159262, + 1.099599999684169 + ], + [ + 0.9000000003160219, + 1.099799999684074, + 0.900400000315831 + ], + [ + 1.0999999996839784, + 0.9002000003159262, + 1.099599999684169 + ], + [ + 0.9000000003160219, + 1.099799999684074, + 0.900400000315831 + ], + [ + 1.0999999996839784, + 0.9002000003159262, + 1.099599999684169 + ], + [ + 0.9000000003160219, + 1.099799999684074, + 0.900400000315831 + ] + ], + "variable": "v" + } + ], + "canonical_structure": null, + "encoding": "explicit", + "exception": null, + "formulation": "ac", + "objective": 15890.889962769339, + "process_peak_rss_bytes": { + "after_canonicalization": 145260544, + "after_construction": 145260544, + "after_solve": 151011328 + }, + "profile": "time_varying", + "residuals": { + "Pg_box_abs": 0.0, + "Qg_box_abs": 0.0, + "active_balance_abs": 1.4143797244514644e-11, + "reactive_balance_abs": 4.3921227765864046e-11, + "reference_angle_abs": 1.42043256342169e-29, + "voltage_box_abs": 0.0 + }, + "solve_time": null, + "solver": "IPOPT", + "solver_iterations": "Not available", + "source_structure": { + "constraint_objects": 13, + "equality_objects": 7, + "explicit_inequality_objects": 6, + "explicit_scalar_inequalities": 90, + "scalar_equalities": 57, + "scalar_variables": 72, + "variable_objects": 4, + "variable_shapes": { + "Pg": [ + 3, + 3 + ], + "Qg": [ + 3, + 3 + ], + "theta": [ + 9, + 3 + ], + "v": [ + 9, + 3 + ] + } + }, + "status": "optimal", + "timing_seconds": { + "canonicalization": null, + "construction": 0.0028855419950559735, + "solve": 0.017188041005283594 + }, + "values": { + "Pg": [ + [ + 0.8875316255809601, + 0.8979993106260531, + 0.9084735790503665 + ], + [ + 1.3304185127070476, + 1.3432060643869943, + 1.355994458032119 + ], + [ + 0.9329645840470646, + 0.9418745653948093, + 0.9507855968710855 + ] + ], + "Qg": [ + [ + 0.12320587093201948, + 0.12984729642546342, + 0.13651635923416333 + ], + [ + -0.007557496229255824, + 0.0006087211906370339, + 0.00882096832217921 + ], + [ + -0.23142854757182427, + -0.22607367784211915, + -0.2206931946310912 + ] + ], + "theta": [ + [ + 1.42043256342169e-29, + -4.111761133273328e-31, + -5.994570731297727e-31 + ], + [ + 0.08488201709242316, + 0.08543726926161592, + 0.08599142318598364 + ], + [ + 0.05644802800423347, + 0.056732363737759264, + 0.057015762385411395 + ], + [ + -0.04247313646323516, + -0.043002825556372026, + -0.043533586062432475 + ], + [ + -0.06866574538727838, + -0.06952547368721448, + -0.07038726216586606 + ], + [ + 0.010681697266050035, + 0.01052310806907226, + 0.010363463154365102 + ], + [ + -0.02040608701596186, + -0.02088949606089891, + -0.021374347469717125 + ], + [ + 0.01591660859289077, + 0.015808922461341347, + 0.01570020476757064 + ], + [ + -0.07958164620864602, + -0.08058284230236024, + -0.08158663355596422 + ] + ], + "v": [ + [ + 1.0999999940792209, + 1.0997999999314474, + 1.0995999999675645 + ], + [ + 1.0969545161456202, + 1.0971697786855095, + 1.0973870207632037 + ], + [ + 1.0863646209228475, + 1.0864320420590754, + 1.0865006078174613 + ], + [ + 1.094535591432713, + 1.0940108769692798, + 1.0934849145498602 + ], + [ + 1.0849683484769521, + 1.0842321107150856, + 1.0834943120733989 + ], + [ + 1.099999999995358, + 1.09979999999533, + 1.099599999995393 + ], + [ + 1.0896876354443688, + 1.0892841848070776, + 1.088880439070822 + ], + [ + 1.0999999999954466, + 1.0997999999954582, + 1.0995999999955384 + ], + [ + 1.072397006137321, + 1.0715368793556044, + 1.0706746843628556 + ] + ] + } + }, + "formulation": "ac", + "gated_value_names": [ + "Pg" + ], + "leaf": { + "accepted": true, + "binding_probes": [ + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "lower_face_coordinates": 5, + "maximum_face_residual": 4.937634190405049e-10, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 4, + "values": [ + [ + 0.1000000004727963, + 2.497599999516803, + 0.10480000049376342 + ], + [ + 3.0, + 0.1029, + 2.9942 + ], + [ + 0.10000000015702303, + 2.6973999998370797, + 0.1052000001689156 + ] + ], + "variable": "Pg" + }, + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "lower_face_coordinates": 5, + "maximum_face_residual": 3.832200778930428e-09, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 4, + "values": [ + [ + -2.9999999962386497, + 2.993999996203515, + -2.987999996167799 + ], + [ + 2.9999999962386497, + -2.993999996203515, + 2.987999996167799 + ], + [ + -2.9999999962386497, + 2.993999996203515, + -2.987999996167799 + ] + ], + "variable": "Qg" + }, + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "lower_face_coordinates": 14, + "maximum_face_residual": 3.160220973796868e-10, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 13, + "values": [ + [ + 0.900000000316022, + 1.0997999996840737, + 0.900400000315831 + ], + [ + 1.099999999683978, + 0.9002000003159264, + 1.0995999996841692 + ], + [ + 0.900000000316022, + 1.0997999996840737, + 0.900400000315831 + ], + [ + 1.099999999683978, + 0.9002000003159264, + 1.0995999996841692 + ], + [ + 0.900000000316022, + 1.0997999996840737, + 0.900400000315831 + ], + [ + 1.099999999683978, + 0.9002000003159264, + 1.0995999996841692 + ], + [ + 0.900000000316022, + 1.0997999996840737, + 0.900400000315831 + ], + [ + 1.099999999683978, + 0.9002000003159264, + 1.0995999996841692 + ], + [ + 0.900000000316022, + 1.0997999996840737, + 0.900400000315831 + ] + ], + "variable": "v" + } + ], + "canonical_structure": null, + "encoding": "leaf", + "exception": null, + "formulation": "ac", + "objective": 15890.889962791854, + "process_peak_rss_bytes": { + "after_canonicalization": 144752640, + "after_construction": 144752640, + "after_solve": 150487040 + }, + "profile": "time_varying", + "residuals": { + "Pg_box_abs": 0.0, + "Qg_box_abs": 0.0, + "active_balance_abs": 3.3218872097506846e-11, + "reactive_balance_abs": 1.0317544041349436e-10, + "reference_angle_abs": 1.3683003660685092e-35, + "voltage_box_abs": 0.0 + }, + "solve_time": null, + "solver": "IPOPT", + "solver_iterations": "Not available", + "source_structure": { + "constraint_objects": 7, + "equality_objects": 7, + "explicit_inequality_objects": 0, + "explicit_scalar_inequalities": 0, + "scalar_equalities": 57, + "scalar_variables": 72, + "variable_objects": 4, + "variable_shapes": { + "Pg": [ + 3, + 3 + ], + "Qg": [ + 3, + 3 + ], + "theta": [ + 9, + 3 + ], + "v": [ + 9, + 3 + ] + } + }, + "status": "optimal", + "timing_seconds": { + "canonicalization": null, + "construction": 0.0029602909926325083, + "solve": 0.017538333020638674 + }, + "values": { + "Pg": [ + [ + 0.8875316254247865, + 0.8979993106246178, + 0.908473579050346 + ], + [ + 1.3304185127891555, + 1.3432060643877675, + 1.35599445803213 + ], + [ + 0.9329645841349582, + 0.9418745653956324, + 0.9507855968710964 + ] + ], + "Qg": [ + [ + 0.12320582699748675, + 0.129847296023844, + 0.13651635922901845 + ], + [ + -0.007557470616392711, + 0.000608721424800279, + 0.008820968325168066 + ], + [ + -0.23142852415300572, + -0.22607367762802139, + -0.22069319462836967 + ] + ], + "theta": [ + [ + 1.4128122858033079e-36, + -1.3683003660685092e-35, + -8.130439880410215e-37 + ], + [ + 0.08488201556054321, + 0.08543726924754587, + 0.08599142318580237 + ], + [ + 0.05644802647136395, + 0.056732363723684606, + 0.05701576238523087 + ], + [ + -0.042473136976245246, + -0.043002825561113935, + -0.043533586062493315 + ], + [ + -0.06866574641090141, + -0.06952547369664827, + -0.07038726216598691 + ], + [ + 0.01068169578288488, + 0.010523108055457489, + 0.0103634631541907 + ], + [ + -0.020406088476117034, + -0.020889496074302814, + -0.02137434746988879 + ], + [ + 0.01591660714916105, + 0.015808922448085957, + 0.015700204767400493 + ], + [ + -0.07958164726422123, + -0.08058284231209666, + -0.08158663355608893 + ] + ], + "v": [ + [ + 1.0999999862103822, + 1.0997999998595827, + 1.0995999999666504 + ], + [ + 1.0969545176127071, + 1.097169778698934, + 1.0973870207633805 + ], + [ + 1.0863646222037746, + 1.0864320420708045, + 1.0865006078176132 + ], + [ + 1.0945355858339854, + 1.0940108769181394, + 1.0934849145492114 + ], + [ + 1.084968344697933, + 1.0842321106805641, + 1.0834943120729612 + ], + [ + 1.099999999995532, + 1.0997999999953523, + 1.099599999995396 + ], + [ + 1.089687635444469, + 1.089284184807098, + 1.0888804390708264 + ], + [ + 1.099999999995584, + 1.099799999995477, + 1.0995999999955437 + ], + [ + 1.0723970022955256, + 1.071536879320503, + 1.070674684362412 + ] + ] + } + }, + "objective_absolute_residual": 2.251545083709061e-08, + "profile": "time_varying", + "result_schemas_match": true, + "value_absolute_residuals": { + "Pg": 1.5617362958408876e-10, + "Qg": 4.3934532734102305e-08, + "theta": 1.532869518816593e-09, + "v": 7.868838691749147e-09 + } + }, + { + "binding_probe_value_absolute_residuals": { + "Pg": 5.235856193053223e-11, + "p_flows": 7.937828172543959e-11 + }, + "binding_probes_passed": true, + "both_accepted": true, + "equivalent": true, + "explicit": { + "accepted": true, + "binding_probes": [ + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "lower_face_coordinates": 5, + "maximum_face_residual": 4.924105567738479e-10, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 4, + "values": [ + [ + 0.10000000049241017, + 2.4999999995075894, + 0.10000000049241017 + ], + [ + 3.0000000000523586, + 0.09999999994764175, + 3.0000000000523586 + ], + [ + 0.10000000017026256, + 2.699999999829738, + 0.10000000017026256 + ] + ], + "variable": "Pg" + }, + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "lower_face_coordinates": 14, + "maximum_face_residual": 1.1396846577582664e-08, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 13, + "values": [ + [ + -2.4999999998883067, + 2.4999999998883067, + -2.4999999998883067 + ], + [ + 2.4999999998883067, + -2.4999999998883067, + 2.4999999998883067 + ], + [ + -1.4999999886031534, + 1.4999999886031534, + -1.4999999886031534 + ], + [ + 3.0000000000793783, + -3.0000000000793783, + 3.0000000000793783 + ], + [ + -1.4999999886031534, + 1.4999999886031534, + -1.4999999886031534 + ], + [ + 2.4999999998883067, + -2.4999999998883067, + 2.4999999998883067 + ], + [ + -2.4999999998883067, + 2.4999999998883067, + -2.4999999998883067 + ], + [ + 2.4999999998883067, + -2.4999999998883067, + 2.4999999998883067 + ], + [ + -2.4999999998883067, + 2.4999999998883067, + -2.4999999998883067 + ] + ], + "variable": "p_flows" + } + ], + "canonical_structure": { + "backend": "SCIPY", + "canonical_variables": 45, + "coefficient_columns": 45, + "coefficient_nonzeros": 153, + "coefficient_rows": 108, + "equality_rows": 36, + "nonnegative_rows": 72, + "quadratic_nonzeros": 27, + "reductions": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ] + }, + "encoding": "explicit", + "exception": null, + "formulation": "lossy_dc", + "objective": 15648.763804535974, + "process_peak_rss_bytes": { + "after_canonicalization": 146309120, + "after_construction": 144965632, + "after_solve": 146833408 + }, + "profile": "static", + "residuals": { + "Pg_box_abs": 0.0, + "active_balance_abs": 2.220446049250313e-16, + "flow_box_abs": 0.0 + }, + "solve_time": 0.000195706, + "solver": "CLARABEL", + "solver_iterations": 6, + "source_structure": { + "constraint_objects": 5, + "equality_objects": 1, + "explicit_inequality_objects": 4, + "explicit_scalar_inequalities": 72, + "scalar_equalities": 27, + "scalar_variables": 36, + "variable_objects": 2, + "variable_shapes": { + "Pg": [ + 3, + 3 + ], + "p_flows": [ + 9, + 3 + ] + } + }, + "status": "optimal", + "timing_seconds": { + "canonicalization": 0.01370645797578618, + "construction": 0.0021739579970017076, + "solve": 0.0008712919661775231 + }, + "values": { + "Pg": [ + [ + 0.8557768064315612, + 0.8656449900480856, + 0.8755131736646327 + ], + [ + 1.3310052583650287, + 1.343775848754882, + 1.3565464391447117 + ], + [ + 0.9317179352034104, + 0.9405791611970322, + 0.9494403871906555 + ] + ], + "p_flows": [ + [ + 0.8557768064315611, + 0.8656449900480856, + 0.8755131736646327 + ], + [ + 0.32693342046680823, + 0.33076543001910863, + 0.33459745130063917 + ], + [ + -0.5640665795331917, + -0.5692345699808915, + -0.5744025486993608 + ], + [ + 0.9317179352034104, + 0.9405791611970322, + 0.9494403871906554 + ], + [ + 0.36765135567021856, + 0.3713445912161408, + 0.37503783849129463 + ], + [ + -0.6223486443297814, + -0.6286554087838592, + -0.6349621615087053 + ], + [ + -1.3310052583650287, + -1.343775848754882, + -1.3565464391447117 + ], + [ + 0.7086566140352472, + 0.7151204399710228, + 0.7215842776360065 + ], + [ + -0.5288433859647529, + -0.5348795600289771, + -0.5409157223639935 + ] + ] + } + }, + "formulation": "lossy_dc", + "gated_value_names": [ + "Pg" + ], + "leaf": { + "accepted": true, + "binding_probes": [ + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "lower_face_coordinates": 5, + "maximum_face_residual": 4.924102098291527e-10, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 4, + "values": [ + [ + 0.10000000049241022, + 2.49999999950759, + 0.10000000049241022 + ], + [ + 3.0, + 0.1, + 3.0 + ], + [ + 0.10000000017026259, + 2.699999999829738, + 0.10000000017026259 + ] + ], + "variable": "Pg" + }, + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "lower_face_coordinates": 14, + "maximum_face_residual": 1.1396853460965417e-08, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 13, + "values": [ + [ + -2.499999999888306, + 2.499999999888306, + -2.499999999888306 + ], + [ + 2.499999999888306, + -2.499999999888306, + 2.499999999888306 + ], + [ + -1.4999999886031465, + 1.4999999886031465, + -1.4999999886031465 + ], + [ + 3.0, + -3.0, + 3.0 + ], + [ + -1.4999999886031465, + 1.4999999886031465, + -1.4999999886031465 + ], + [ + 2.499999999888306, + -2.499999999888306, + 2.499999999888306 + ], + [ + -2.499999999888306, + 2.499999999888306, + -2.499999999888306 + ], + [ + 2.499999999888306, + -2.499999999888306, + 2.499999999888306 + ], + [ + -2.499999999888306, + 2.499999999888306, + -2.499999999888306 + ] + ], + "variable": "p_flows" + } + ], + "canonical_structure": { + "backend": "SCIPY", + "canonical_variables": 45, + "coefficient_columns": 45, + "coefficient_nonzeros": 153, + "coefficient_rows": 108, + "equality_rows": 36, + "nonnegative_rows": 72, + "quadratic_nonzeros": 27, + "reductions": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ] + }, + "encoding": "leaf", + "exception": null, + "formulation": "lossy_dc", + "objective": 15648.763804535974, + "process_peak_rss_bytes": { + "after_canonicalization": 146243584, + "after_construction": 144801792, + "after_solve": 146751488 + }, + "profile": "static", + "residuals": { + "Pg_box_abs": 0.0, + "active_balance_abs": 2.220446049250313e-16, + "flow_box_abs": 0.0 + }, + "solve_time": 0.000190834, + "solver": "CLARABEL", + "solver_iterations": 6, + "source_structure": { + "constraint_objects": 1, + "equality_objects": 1, + "explicit_inequality_objects": 0, + "explicit_scalar_inequalities": 0, + "scalar_equalities": 27, + "scalar_variables": 36, + "variable_objects": 2, + "variable_shapes": { + "Pg": [ + 3, + 3 + ], + "p_flows": [ + 9, + 3 + ] + } + }, + "status": "optimal", + "timing_seconds": { + "canonicalization": 0.01488633401459083, + "construction": 0.0019033339922316372, + "solve": 0.0008600409491918981 + }, + "values": { + "Pg": [ + [ + 0.8557768064315611, + 0.8656449900480857, + 0.8755131736646329 + ], + [ + 1.3310052583650287, + 1.343775848754882, + 1.3565464391447117 + ], + [ + 0.9317179352034106, + 0.9405791611970322, + 0.9494403871906553 + ] + ], + "p_flows": [ + [ + 0.855776806431561, + 0.8656449900480856, + 0.8755131736646328 + ], + [ + 0.32693342055510516, + 0.33076543010843285, + 0.33459745139099084 + ], + [ + -0.5640665794448948, + -0.5692345698915672, + -0.5744025486090092 + ], + [ + 0.9317179352034105, + 0.9405791611970322, + 0.9494403871906553 + ], + [ + 0.36765135575851565, + 0.37134459130546504, + 0.3750378385816462 + ], + [ + -0.6223486442414844, + -0.628655408694535, + -0.6349621614183539 + ], + [ + -1.3310052583650287, + -1.343775848754882, + -1.3565464391447117 + ], + [ + 0.7086566141235442, + 0.7151204400603471, + 0.7215842777263579 + ], + [ + -0.5288433858764557, + -0.5348795599396529, + -0.5409157222736419 + ] + ] + } + }, + "objective_absolute_residual": 0.0, + "profile": "static", + "result_schemas_match": true, + "value_absolute_residuals": { + "Pg": 2.220446049250313e-16, + "p_flows": 9.035167058968341e-11 + } + }, + { + "binding_probe_value_absolute_residuals": { + "Pg": 6.125899787434719e-11, + "p_flows": 9.876410800302438e-11 + }, + "binding_probes_passed": true, + "both_accepted": true, + "equivalent": true, + "explicit": { + "accepted": true, + "binding_probes": [ + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "lower_face_coordinates": 5, + "maximum_face_residual": 4.937633635293537e-10, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 4, + "values": [ + [ + 0.10000000047279625, + 2.497599999516803, + 0.10480000049376337 + ], + [ + 3.000000000061259, + 0.10289999994127123, + 2.9942000000561477 + ], + [ + 0.10000000015702297, + 2.6973999998370792, + 0.10520000016891555 + ] + ], + "variable": "Pg" + }, + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "lower_face_coordinates": 14, + "maximum_face_residual": 1.146492367709584e-08, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 13, + "values": [ + [ + -2.4999999999116587, + 2.494999999904715, + -2.489999999897638 + ], + [ + 2.4999999999116587, + -2.494999999904715, + 2.489999999897638 + ], + [ + -1.499999988765144, + 1.4969999886506538, + -1.4939999885350763 + ], + [ + 3.000000000093583, + -2.994000000096222, + 2.988000000098764 + ], + [ + -1.499999988765144, + 1.4969999886506538, + -1.4939999885350763 + ], + [ + 2.4999999999116587, + -2.494999999904715, + 2.489999999897638 + ], + [ + -2.4999999999116587, + 2.494999999904715, + -2.489999999897638 + ], + [ + 2.4999999999116587, + -2.494999999904715, + 2.489999999897638 + ], + [ + -2.4999999999116587, + 2.494999999904715, + -2.489999999897638 + ] + ], + "variable": "p_flows" + } + ], + "canonical_structure": { + "backend": "SCIPY", + "canonical_variables": 45, + "coefficient_columns": 45, + "coefficient_nonzeros": 153, + "coefficient_rows": 108, + "equality_rows": 36, + "nonnegative_rows": 72, + "quadratic_nonzeros": 27, + "reductions": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ] + }, + "encoding": "explicit", + "exception": null, + "formulation": "lossy_dc", + "objective": 15648.76380453597, + "process_peak_rss_bytes": { + "after_canonicalization": 146309120, + "after_construction": 144965632, + "after_solve": 146882560 + }, + "profile": "time_varying", + "residuals": { + "Pg_box_abs": 0.0, + "active_balance_abs": 2.220446049250313e-16, + "flow_box_abs": 0.0 + }, + "solve_time": 0.000256669, + "solver": "CLARABEL", + "solver_iterations": 6, + "source_structure": { + "constraint_objects": 5, + "equality_objects": 1, + "explicit_inequality_objects": 4, + "explicit_scalar_inequalities": 72, + "scalar_equalities": 27, + "scalar_variables": 36, + "variable_objects": 2, + "variable_shapes": { + "Pg": [ + 3, + 3 + ], + "p_flows": [ + 9, + 3 + ] + } + }, + "status": "optimal", + "timing_seconds": { + "canonicalization": 0.01337895798496902, + "construction": 0.001986375020351261, + "solve": 0.0012445829925127327 + }, + "values": { + "Pg": [ + [ + 0.8557768064318197, + 0.8656449900485303, + 0.8755131736652653 + ], + [ + 1.331005258364708, + 1.3437758487541704, + 1.3565464391435984 + ], + [ + 0.9317179352034723, + 0.9405791611972991, + 0.9494403871911362 + ] + ], + "p_flows": [ + [ + 0.8557768064318199, + 0.8656449900485302, + 0.8755131736652654 + ], + [ + 0.32693564551956583, + 0.3307684767914676, + 0.334601352908167 + ], + [ + -0.5640643544804342, + -0.5692315232085325, + -0.5743986470918331 + ], + [ + 0.9317179352034725, + 0.9405791611972991, + 0.9494403871911362 + ], + [ + 0.3676535807230383, + 0.3713476379887667, + 0.37504174009930313 + ], + [ + -0.6223464192769618, + -0.6286523620112333, + -0.6349582599006969 + ], + [ + -1.3310052583647078, + -1.3437758487541704, + -1.3565464391435984 + ], + [ + 0.7086588390877461, + 0.7151234867429371, + 0.7215881792429015 + ], + [ + -0.528841160912254, + -0.5348765132570628, + -0.5409118207570983 + ] + ] + } + }, + "formulation": "lossy_dc", + "gated_value_names": [ + "Pg" + ], + "leaf": { + "accepted": true, + "binding_probes": [ + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "lower_face_coordinates": 5, + "maximum_face_residual": 4.937634190405049e-10, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 4, + "values": [ + [ + 0.1000000004727963, + 2.497599999516803, + 0.10480000049376342 + ], + [ + 3.0, + 0.1029, + 2.9942 + ], + [ + 0.10000000015702303, + 2.6973999998370797, + 0.1052000001689156 + ] + ], + "variable": "Pg" + }, + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "lower_face_coordinates": 14, + "maximum_face_residual": 1.1464930338433987e-08, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 13, + "values": [ + [ + -2.499999999911658, + 2.4949999999047145, + -2.4899999998976377 + ], + [ + 2.499999999911658, + -2.4949999999047145, + 2.4899999998976377 + ], + [ + -1.4999999887651374, + 1.496999988650647, + -1.4939999885350697 + ], + [ + 3.0, + -2.994, + 2.988 + ], + [ + -1.4999999887651374, + 1.496999988650647, + -1.4939999885350697 + ], + [ + 2.499999999911658, + -2.4949999999047145, + 2.4899999998976377 + ], + [ + -2.499999999911658, + 2.4949999999047145, + -2.4899999998976377 + ], + [ + 2.499999999911658, + -2.4949999999047145, + 2.4899999998976377 + ], + [ + -2.499999999911658, + 2.4949999999047145, + -2.4899999998976377 + ] + ], + "variable": "p_flows" + } + ], + "canonical_structure": { + "backend": "SCIPY", + "canonical_variables": 45, + "coefficient_columns": 45, + "coefficient_nonzeros": 153, + "coefficient_rows": 108, + "equality_rows": 36, + "nonnegative_rows": 72, + "quadratic_nonzeros": 27, + "reductions": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ] + }, + "encoding": "leaf", + "exception": null, + "formulation": "lossy_dc", + "objective": 15648.763804535969, + "process_peak_rss_bytes": { + "after_canonicalization": 146456576, + "after_construction": 144965632, + "after_solve": 146997248 + }, + "profile": "time_varying", + "residuals": { + "Pg_box_abs": 0.0, + "active_balance_abs": 2.220446049250313e-16, + "flow_box_abs": 0.0 + }, + "solve_time": 0.000168374, + "solver": "CLARABEL", + "solver_iterations": 6, + "source_structure": { + "constraint_objects": 1, + "equality_objects": 1, + "explicit_inequality_objects": 0, + "explicit_scalar_inequalities": 0, + "scalar_equalities": 27, + "scalar_variables": 36, + "variable_objects": 2, + "variable_shapes": { + "Pg": [ + 3, + 3 + ], + "p_flows": [ + 9, + 3 + ] + } + }, + "status": "optimal", + "timing_seconds": { + "canonicalization": 0.016477958008181304, + "construction": 0.002221125003416091, + "solve": 0.00087237503612414 + }, + "values": { + "Pg": [ + [ + 0.8557768064318197, + 0.8656449900485303, + 0.8755131736652652 + ], + [ + 1.3310052583647076, + 1.3437758487541704, + 1.3565464391435982 + ], + [ + 0.9317179352034725, + 0.9405791611972993, + 0.949440387191136 + ] + ], + "p_flows": [ + [ + 0.8557768064318197, + 0.8656449900485302, + 0.875513173665265 + ], + [ + 0.32693564597538105, + 0.3307684772523455, + 0.3346013533765842 + ], + [ + -0.5640643540246189, + -0.5692315227476545, + -0.5743986466234157 + ], + [ + 0.9317179352034725, + 0.9405791611972992, + 0.9494403871911361 + ], + [ + 0.3676535811788535, + 0.37134763844964475, + 0.37504174056772044 + ], + [ + -0.6223464188211464, + -0.6286523615503553, + -0.6349582594322795 + ], + [ + -1.3310052583647076, + -1.3437758487541704, + -1.3565464391435982 + ], + [ + 0.7086588395435612, + 0.7151234872038152, + 0.7215881797113189 + ], + [ + -0.5288411604564386, + -0.5348765127961848, + -0.5409118202886809 + ] + ] + } + }, + "objective_absolute_residual": 1.8189894035458565e-12, + "profile": "time_varying", + "result_schemas_match": true, + "value_absolute_residuals": { + "Pg": 4.440892098500626e-16, + "p_flows": 4.684174159663712e-10 + } + }, + { + "binding_probe_value_absolute_residuals": { + "Pg": 5.235856193053223e-11 + }, + "binding_probes_passed": true, + "both_accepted": true, + "equivalent": true, + "explicit": { + "accepted": true, + "binding_probes": [ + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "lower_face_coordinates": 5, + "maximum_face_residual": 4.924105567738479e-10, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 4, + "values": [ + [ + 0.10000000049241017, + 2.4999999995075894, + 0.10000000049241017 + ], + [ + 3.0000000000523586, + 0.09999999994764175, + 3.0000000000523586 + ], + [ + 0.10000000017026256, + 2.699999999829738, + 0.10000000017026256 + ] + ], + "variable": "Pg" + } + ], + "canonical_structure": { + "backend": "SCIPY", + "canonical_variables": 18, + "coefficient_columns": 18, + "coefficient_nonzeros": 45, + "coefficient_rows": 30, + "equality_rows": 12, + "nonnegative_rows": 18, + "quadratic_nonzeros": 9, + "reductions": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ] + }, + "encoding": "explicit", + "exception": null, + "formulation": "singlenode_dc", + "objective": 15648.763688360272, + "process_peak_rss_bytes": { + "after_canonicalization": 146063360, + "after_construction": 144818176, + "after_solve": 146604032 + }, + "profile": "static", + "residuals": { + "Pg_box_abs": 0.0, + "active_balance_abs": 2.6645352591003757e-15 + }, + "solve_time": 9.2543e-05, + "solver": "CLARABEL", + "solver_iterations": 5, + "source_structure": { + "constraint_objects": 3, + "equality_objects": 1, + "explicit_inequality_objects": 2, + "explicit_scalar_inequalities": 18, + "scalar_equalities": 3, + "scalar_variables": 9, + "variable_objects": 1, + "variable_shapes": { + "Pg": [ + 3, + 3 + ] + } + }, + "status": "optimal", + "timing_seconds": { + "canonicalization": 0.011929375003091991, + "construction": 0.0018407920142635703, + "solve": 0.0007074159802868962 + }, + "values": { + "Pg": [ + [ + 0.855776797049529, + 0.8656449805742867, + 0.8755131640996556 + ], + [ + 1.3310052625321762, + 1.3437758529666535, + 1.3565464434007206 + ], + [ + 0.9317179404182921, + 0.9405791664590576, + 0.949440392499622 + ] + ] + } + }, + "formulation": "singlenode_dc", + "gated_value_names": [ + "Pg" + ], + "leaf": { + "accepted": true, + "binding_probes": [ + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "lower_face_coordinates": 5, + "maximum_face_residual": 4.924102098291527e-10, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 4, + "values": [ + [ + 0.10000000049241022, + 2.49999999950759, + 0.10000000049241022 + ], + [ + 3.0, + 0.1, + 3.0 + ], + [ + 0.10000000017026259, + 2.699999999829738, + 0.10000000017026259 + ] + ], + "variable": "Pg" + } + ], + "canonical_structure": { + "backend": "SCIPY", + "canonical_variables": 18, + "coefficient_columns": 18, + "coefficient_nonzeros": 45, + "coefficient_rows": 30, + "equality_rows": 12, + "nonnegative_rows": 18, + "quadratic_nonzeros": 9, + "reductions": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ] + }, + "encoding": "leaf", + "exception": null, + "formulation": "singlenode_dc", + "objective": 15648.763688360266, + "process_peak_rss_bytes": { + "after_canonicalization": 146440192, + "after_construction": 145063936, + "after_solve": 146931712 + }, + "profile": "static", + "residuals": { + "Pg_box_abs": 0.0, + "active_balance_abs": 2.6645352591003757e-15 + }, + "solve_time": 8.1291e-05, + "solver": "CLARABEL", + "solver_iterations": 5, + "source_structure": { + "constraint_objects": 1, + "equality_objects": 1, + "explicit_inequality_objects": 0, + "explicit_scalar_inequalities": 0, + "scalar_equalities": 3, + "scalar_variables": 9, + "variable_objects": 1, + "variable_shapes": { + "Pg": [ + 3, + 3 + ] + } + }, + "status": "optimal", + "timing_seconds": { + "canonicalization": 0.013238125015050173, + "construction": 0.0018322080140933394, + "solve": 0.0007080420036800206 + }, + "values": { + "Pg": [ + [ + 0.8557767970495291, + 0.8656449805742865, + 0.8755131640996552 + ], + [ + 1.3310052625321762, + 1.3437758529666533, + 1.3565464434007204 + ], + [ + 0.9317179404182923, + 0.9405791664590577, + 0.9494403924996218 + ] + ] + } + }, + "objective_absolute_residual": 5.4569682106375694e-12, + "profile": "static", + "result_schemas_match": true, + "value_absolute_residuals": { + "Pg": 4.440892098500626e-16 + } + }, + { + "binding_probe_value_absolute_residuals": { + "Pg": 6.125899787434719e-11 + }, + "binding_probes_passed": true, + "both_accepted": true, + "equivalent": true, + "explicit": { + "accepted": true, + "binding_probes": [ + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "lower_face_coordinates": 5, + "maximum_face_residual": 4.937633635293537e-10, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 4, + "values": [ + [ + 0.10000000047279625, + 2.497599999516803, + 0.10480000049376337 + ], + [ + 3.000000000061259, + 0.10289999994127123, + 2.9942000000561477 + ], + [ + 0.10000000015702297, + 2.6973999998370792, + 0.10520000016891555 + ] + ], + "variable": "Pg" + } + ], + "canonical_structure": { + "backend": "SCIPY", + "canonical_variables": 18, + "coefficient_columns": 18, + "coefficient_nonzeros": 45, + "coefficient_rows": 30, + "equality_rows": 12, + "nonnegative_rows": 18, + "quadratic_nonzeros": 9, + "reductions": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ] + }, + "encoding": "explicit", + "exception": null, + "formulation": "singlenode_dc", + "objective": 15648.763688360274, + "process_peak_rss_bytes": { + "after_canonicalization": 146292736, + "after_construction": 145014784, + "after_solve": 146817024 + }, + "profile": "time_varying", + "residuals": { + "Pg_box_abs": 0.0, + "active_balance_abs": 1.7763568394002505e-15 + }, + "solve_time": 7.7126e-05, + "solver": "CLARABEL", + "solver_iterations": 5, + "source_structure": { + "constraint_objects": 3, + "equality_objects": 1, + "explicit_inequality_objects": 2, + "explicit_scalar_inequalities": 18, + "scalar_equalities": 3, + "scalar_variables": 9, + "variable_objects": 1, + "variable_shapes": { + "Pg": [ + 3, + 3 + ] + } + }, + "status": "optimal", + "timing_seconds": { + "canonicalization": 0.011934417008887976, + "construction": 0.001896333007607609, + "solve": 0.0006738750380463898 + }, + "values": { + "Pg": [ + [ + 0.8557767970528549, + 0.8656449805839541, + 0.8755131641156433 + ], + [ + 1.3310052625250341, + 1.3437758529448105, + 1.3565464433638905 + ], + [ + 0.9317179404221091, + 0.940579166471234, + 0.9494403925204642 + ] + ] + } + }, + "formulation": "singlenode_dc", + "gated_value_names": [ + "Pg" + ], + "leaf": { + "accepted": true, + "binding_probes": [ + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "lower_face_coordinates": 5, + "maximum_face_residual": 4.937634190405049e-10, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 4, + "values": [ + [ + 0.1000000004727963, + 2.497599999516803, + 0.10480000049376342 + ], + [ + 3.0, + 0.1029, + 2.9942 + ], + [ + 0.10000000015702303, + 2.6973999998370797, + 0.1052000001689156 + ] + ], + "variable": "Pg" + } + ], + "canonical_structure": { + "backend": "SCIPY", + "canonical_variables": 18, + "coefficient_columns": 18, + "coefficient_nonzeros": 45, + "coefficient_rows": 30, + "equality_rows": 12, + "nonnegative_rows": 18, + "quadratic_nonzeros": 9, + "reductions": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ] + }, + "encoding": "leaf", + "exception": null, + "formulation": "singlenode_dc", + "objective": 15648.76368836027, + "process_peak_rss_bytes": { + "after_canonicalization": 146210816, + "after_construction": 144834560, + "after_solve": 146718720 + }, + "profile": "time_varying", + "residuals": { + "Pg_box_abs": 0.0, + "active_balance_abs": 2.6645352591003757e-15 + }, + "solve_time": 7.8209e-05, + "solver": "CLARABEL", + "solver_iterations": 5, + "source_structure": { + "constraint_objects": 1, + "equality_objects": 1, + "explicit_inequality_objects": 0, + "explicit_scalar_inequalities": 0, + "scalar_equalities": 3, + "scalar_variables": 9, + "variable_objects": 1, + "variable_shapes": { + "Pg": [ + 3, + 3 + ] + } + }, + "status": "optimal", + "timing_seconds": { + "canonicalization": 0.013085540966130793, + "construction": 0.0018201249768026173, + "solve": 0.0006988339591771364 + }, + "values": { + "Pg": [ + [ + 0.8557767970528549, + 0.8656449805839538, + 0.8755131641156432 + ], + [ + 1.3310052625250337, + 1.3437758529448103, + 1.356546443363891 + ], + [ + 0.9317179404221089, + 0.9405791664712336, + 0.9494403925204639 + ] + ] + } + }, + "objective_absolute_residual": 3.637978807091713e-12, + "profile": "time_varying", + "result_schemas_match": true, + "value_absolute_residuals": { + "Pg": 4.440892098500626e-16 + } + } + ], + "schema_version": 1, + "stage": "M14a.1_leaf_bound_qualification" +} diff --git a/plans/milestone-14-time-vectorization.md b/plans/milestone-14-time-vectorization.md index a9b2a01..c79967f 100644 --- a/plans/milestone-14-time-vectorization.md +++ b/plans/milestone-14-time-vectorization.md @@ -2,15 +2,24 @@ ## Status -**In progress; M14a complete.** The frozen legacy Case9 and Case118 scaling -ladders completed and the independently reconstructed baseline authorizes M14b. -The immutable record is bound to: +**In progress; M14a and M14a.1 complete.** The frozen legacy Case9 and Case118 +scaling ladders completed, and the formulation-specific leaf-bound gate passed. +Together these records authorize M14b. The M14a baseline is bound to: - execution commit `1dd5e36dcae5ad9c8176b1d1202f1055acf95c03`; - analyzer commit `457ec9200050eae2a60dd470a131155a0ddaa53f`; and - promoted-record SHA-256 `44f6f0b9f3c3b51621f6952dd2efa1eb2d169757895acaba75bba6f04f5edb53`. +The immutable M14a.1 result is bound to execution commit +`1f45651fa8450cdfc50e55dd024eb1fbcc4b7c06` and SHA-256 +`6efcb1c077fd8201435faf6df11512d4174b0c24edd06c82ffccee3a131a4614`. +All paired and binding-probe gates passed. Lossy DC selects leaf bounds for +`Pg` and `p_flows`; single-node DC selects them for `Pg`. AC records isolated +compatibility for `Pg`, `Qg`, and `v` but retains explicit inequalities because +the isolated fixture does not retire the production lifted-DNLP and terminal- +policy risk. + The Case118 annual hierarchy experiment remains paused at S4 until the annual lossy-DC outer problem passes the remaining M14 construction, canonicalization, solve, equivalence, and resource gates below. M14b is next. From aacadd7b22da4782950d5d04ded3565c9fbae2c8 Mon Sep 17 00:00:00 2001 From: Bennet Meyers Date: Thu, 27 Aug 2026 16:02:12 -0700 Subject: [PATCH 20/28] docs(m14b): open vectorized horizon assembly Freeze the M14a.1 representation decisions and record focused qualification gates for storage, nondispatchable, HVDC, and load-shedding boxes before component leaf-bound migration. --- CLAUDE.md | 2 +- .../m14_time_vectorization/M14B_PROTOCOL.md | 81 +++++++++++++++++++ plans/milestone-14-time-vectorization.md | 42 +++++++++- 3 files changed, 120 insertions(+), 5 deletions(-) create mode 100644 experiments/m14_time_vectorization/M14B_PROTOCOL.md diff --git a/CLAUDE.md b/CLAUDE.md index 49f760b..a653fa6 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -737,7 +737,7 @@ is present. | 11 — SOCP (convex) network model | 🔲 Future | | | 12 — Extend battery parameters: final SoC, penalty vs constraint | ✅ Complete | Storage-owned terminal equality or zero-shortfall constraints and linear/quadratic, one-/two-sided terminal costs, consistently composed across formulations. See `plans/milestone-12-storage-terminal-soc.md`. | | 13 — Extend CVXPY parameterization for problem data | 🔲 Future | Faster repeated solves of the same graph over new data | -| 14 — Time-vectorized multistep formulations | 🟧 In progress / blocking | M14a's frozen legacy baseline and M14a.1's formulation-specific leaf-bound qualification are complete and authorize M14b. Lossy DC and single-node DC may use their qualified leaf boxes; AC retains explicit inequalities. Next, add the explicit time-last tensor assembly mode using SCIPY canonicalization alongside the retained stepwise/CPP path, preserving formulation, failure, audit, and result contracts. Vectorized lossy DC remains the first delivery and blocks resumption of the Case118 annual S4 outer solve after macOS killed the repeated annual graph under extreme compressed-memory pressure. See `plans/milestone-14-time-vectorization.md`. | +| 14 — Time-vectorized multistep formulations | 🟧 M14b open / blocking | M14a's frozen legacy baseline and M14a.1's formulation-specific leaf-bound qualification are complete. M14b is implementing the explicit time-last tensor assembly mode using SCIPY canonicalization alongside the retained stepwise/CPP path. Lossy DC and single-node DC may use the qualified generator/network leaf boxes; storage, nondispatchable, HVDC, and load-shedding boxes require focused convex qualification, while AC permits no new leaf-bound migration. Vectorized lossy DC remains the first delivery and blocks resumption of the Case118 annual S4 outer solve after macOS killed the repeated annual graph under extreme compressed-memory pressure. See `plans/milestone-14-time-vectorization.md` and `experiments/m14_time_vectorization/M14B_PROTOCOL.md`. | | 15 — Full lossy HVDC (sign-switching converter losses) | 🔲 Future | charge/discharge-style split of `p_in`; adds fixed converter loss (`LOSS0`); enables losses in `free` and zero-straddling `band` steps; reactive-power support proposed. See `plans/milestone-15-full-lossy-hvdc.md`. | | 16 — Unify grid component model patterns | ✅ Complete | Generators, storage, nondispatchable units, and HVDC share formulation-specific injection and operating-set APIs, temporal coupling slots, and device-owned cost boundaries. Includes first-class `DispatchableGenerator`, MATPOWER fallback, stable identity for external ND/HVDC tables, and collapsed singlenode reuse. See `plans/milestone-16-unify-components.md` and `memories/M16-in-flight-record.md`. | | 17 — Hierarchical DC→AC receding-horizon dispatch | ✅ Complete | The capstone controller passes **identity-aligned SoC signposts only** (not other setpoints) from long-horizon `lossy_dc` planning into short AC-OPF windows, executes only residual-checked target-conditioned first actions, supports causal shifted initialization with audited recovery, and retains the complete plan/attempt tree. M17 fixes the validated `lossy_dc`→`ac` workflow; configurable formulations and additional layers are M21. See `plans/milestone-17-hierarchical-dc-ac.md`. | diff --git a/experiments/m14_time_vectorization/M14B_PROTOCOL.md b/experiments/m14_time_vectorization/M14B_PROTOCOL.md new file mode 100644 index 0000000..408a5dc --- /dev/null +++ b/experiments/m14_time_vectorization/M14B_PROTOCOL.md @@ -0,0 +1,81 @@ +# M14b vectorized horizon-assembly protocol + +## Status and authority + +M14b is open. It is authorized by the immutable M14a legacy baseline and the +M14a.1 leaf-bound qualification record. M14b introduces the internal +time-last horizon assembly contract while keeping the public stepwise/CPP path +available and unchanged by default. + +The frozen representation decisions are: + +- lossy DC: leaf bounds are authorized for dispatchable `Pg` and network + `p_flows`; +- single-node DC: leaf bounds are authorized for dispatchable `Pg`; +- AC: M14a.1 is isolated compatibility evidence only. No new AC leaf-bound + migration is authorized. The existing production voltage leaf attribute is + preserved, while generator and component operating boxes remain explicit; + and +- all non-box equations and coupled feasible sets remain explicit constraints. + +Every retained build records the temporal assembly mode, canonicalization +backend, and representation selected for each variable family. + +## Temporal assembly contract + +The vectorized path owns one CVXPY object per logical horizon variable or +expression, with time on the final axis. Per-step scalar, vector, and matrix +objects become `(T,)`, `(n, T)`, and `(m, n, T)` respectively. Storage SoC is +a boundary variable with shape `(n_storage, T + 1)`. Public inputs and results +remain time first; preparation and extraction transpose the time axis exactly +once. + +Every prepared field declares one of `static`, `interval`, or `boundary`. +Static data remain native-size and may be exposed through zero-stride broadcast +views. Interval data append `T`; boundary data append `T + 1`. Temporal class +is schema-owned and is never inferred from coincidentally constant values. + +The vectorized path uses SCIPY canonicalization. The stepwise path continues to +use CPP. Backend selection is explicit provenance, not an automatic heuristic. + +## Component-specific box qualification + +M14a.1 qualified formulation-owned generator and network boxes only. The +following component boxes are not implicitly covered: + +| Family | Convex formulations requiring a focused gate | Required cases | +|---|---|---| +| Storage `b` and `soc` | lossy DC and single-node DC separately | lower/upper power and energy faces; recurrence; initial state; equality, shortfall, and soft terminal policies | +| Nondispatchable `p_nd` | lossy DC and single-node DC separately | zero, availability-limited, and rating-limited coordinates; time-varying availability; identity alignment | +| HVDC `p_hvdc_in` | lossy DC and single-node DC separately | positive-only, negative-only, zero-straddling, degenerate, and time-varying boxes; unchanged affine loss branch | +| `load_shed_fraction` | lossy DC and single-node DC separately | ineligible zero-width entries; binding upper faces; time-varying eligibility; served-load and cost reconstruction | + +Until its gate passes, each family uses explicit vectorized inequalities. A +failed or neutral leaf-bound result does not block M14b: explicit inequalities +are a valid vectorized representation. + +AC component boxes remain explicit during M14. AC storage and inverter circles, +branch apparent-power limits, network equations, storage recurrence and +terminal obligations, and HVDC coupling are coupled or equality constraints, +not leaf-bound candidates. + +Each focused gate must compare explicit and leaf encodings with identical +prepared arrays, equations, costs, solver configuration, and SCIPY backend. It +must retain binding-face evidence, public results, independent residuals, +canonical dimensions/nonzeros, solver classification, and a local selection +decision. No convex result authorizes AC. + +## Delivery order + +1. Freeze typed temporal-field and variable-representation schemas. +2. Add vectorized component request/contribution contracts without calling + scalar hooks `T` times. +3. Implement compatibility publication and extraction without recreating a + length-`T` CVXPY object list. +4. Run the focused component-box gates and freeze their local decisions. +5. Hand the completed assembly contract to M14c's vectorized lossy-DC builder. + +Structural tests cover time-last shapes, `T=1`, static broadcasting, interval +identity alignment, boundary indexing, DCP validity of every component term, +duplicate-name rejection, explicit backend selection, and unchanged stepwise +behavior. diff --git a/plans/milestone-14-time-vectorization.md b/plans/milestone-14-time-vectorization.md index c79967f..27150d1 100644 --- a/plans/milestone-14-time-vectorization.md +++ b/plans/milestone-14-time-vectorization.md @@ -2,9 +2,10 @@ ## Status -**In progress; M14a and M14a.1 complete.** The frozen legacy Case9 and Case118 -scaling ladders completed, and the formulation-specific leaf-bound gate passed. -Together these records authorize M14b. The M14a baseline is bound to: +**In progress; M14b open.** The frozen legacy Case9 and Case118 scaling +ladders completed, and the formulation-specific leaf-bound gate passed. +Together these records authorize the horizon-assembly work now in progress. +The M14a baseline is bound to: - execution commit `1dd5e36dcae5ad9c8176b1d1202f1055acf95c03`; - analyzer commit `457ec9200050eae2a60dd470a131155a0ddaa53f`; and @@ -22,7 +23,7 @@ policy risk. The Case118 annual hierarchy experiment remains paused at S4 until the annual lossy-DC outer problem passes the remaining M14 construction, -canonicalization, solve, equivalence, and resource gates below. M14b is next. +canonicalization, solve, equivalence, and resource gates below. ## Motivation @@ -350,6 +351,39 @@ complete horizon once; it does not call the scalar step builder `T` times. The existing stepwise hooks and builder remain executable rather than becoming test-only dead code. +M14b uses the immutable M14a.1 decisions as a closed representation registry, +not as blanket authorization for every component-owned interval. Lossy DC may +use qualified leaf bounds for formulation-owned `Pg` and `p_flows`, and +single-node DC may use them for formulation-owned `Pg`. AC retains its current +production representation: no new AC leaf-bound migration is authorized by +the isolated M14a.1 fixture. In particular, the existing production voltage +leaf attribute is preserved as an established compatibility behavior; it does +not authorize moving `Pg`, `Qg`, or component boxes into leaf attributes. + +The following component-owned boxes require focused, formulation-specific +qualification before they may use leaf attributes in a vectorized builder: + +| Component box | Required probe | Default until qualified | +|---|---|---| +| Storage DC real power and all-formulation SoC | Both power faces, both SoC faces, recurrence, initial state, and equality/shortfall/soft terminal behavior | Explicit inequalities | +| Nondispatchable real power | Zero availability, availability-limited and rating-limited coordinates, and time-varying availability with identity alignment | Explicit inequalities | +| HVDC from-terminal power | Positive-only, negative-only, zero-straddling, degenerate, and time-varying boxes while preserving the selected affine loss coupling | Explicit inequalities | +| Load-shed fraction | Zero-width ineligible entries, active upper faces, time-varying eligibility, served-load reconstruction, and shedding cost | Explicit inequalities | + +Lossy DC and single-node DC qualify independently even when their component +equations are shared. AC component boxes remain explicit for M14 regardless of +convex probe results unless a later production-structure DNLP gate explicitly +changes that decision. Coupled apparent-power circles, storage recurrence and +terminal constraints, HVDC loss equalities, and network equations are not +boxes and are never candidates for leaf-bound replacement. + +These focused probes are small deterministic M14b gates, not new scaling +studies. Each compares explicit and leaf representations through binding +faces, objective/component costs, public results, independent physical +residuals, canonical structure, and solver classification. A box may remain +explicit without blocking vectorization; qualification controls only its +representation. + The compatibility adapter must be designed and tested explicitly. It must not materialize thousands of new CVXPY objects merely to recreate the old internal list representation. If an internal/public representation must change, freeze From a162fce6081cb79565e8cb33c107f47bc5decda3 Mon Sep 17 00:00:00 2001 From: Bennet Meyers Date: Thu, 27 Aug 2026 16:42:22 -0700 Subject: [PATCH 21/28] feat(m14b): define vectorized horizon assembly contracts Add typed time-last schemas, mixed-temporality box normalization, frozen representation decisions, and one-call component hooks with shape, convexity, and DCP validation. Preserve the stepwise path and explicitly cover boundary states and multistep T=1 behavior. --- CLAUDE.md | 2 +- .../m14_time_vectorization/M14B_PROTOCOL.md | 15 +- plans/milestone-14-time-vectorization.md | 25 +- src/cvxopf/_component_adapter.py | 138 +++++-- src/cvxopf/_component_assembly.py | 299 ++++++++++----- src/cvxopf/_temporal_assembly.py | 359 ++++++++++++++++++ tests/test_m14b_temporal_contract.py | 311 +++++++++++++++ ...test_m14b_vectorized_component_contract.py | 342 +++++++++++++++++ 8 files changed, 1344 insertions(+), 147 deletions(-) create mode 100644 src/cvxopf/_temporal_assembly.py create mode 100644 tests/test_m14b_temporal_contract.py create mode 100644 tests/test_m14b_vectorized_component_contract.py diff --git a/CLAUDE.md b/CLAUDE.md index a653fa6..501d6f2 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -737,7 +737,7 @@ is present. | 11 — SOCP (convex) network model | 🔲 Future | | | 12 — Extend battery parameters: final SoC, penalty vs constraint | ✅ Complete | Storage-owned terminal equality or zero-shortfall constraints and linear/quadratic, one-/two-sided terminal costs, consistently composed across formulations. See `plans/milestone-12-storage-terminal-soc.md`. | | 13 — Extend CVXPY parameterization for problem data | 🔲 Future | Faster repeated solves of the same graph over new data | -| 14 — Time-vectorized multistep formulations | 🟧 M14b open / blocking | M14a's frozen legacy baseline and M14a.1's formulation-specific leaf-bound qualification are complete. M14b is implementing the explicit time-last tensor assembly mode using SCIPY canonicalization alongside the retained stepwise/CPP path. Lossy DC and single-node DC may use the qualified generator/network leaf boxes; storage, nondispatchable, HVDC, and load-shedding boxes require focused convex qualification, while AC permits no new leaf-bound migration. Vectorized lossy DC remains the first delivery and blocks resumption of the Case118 annual S4 outer solve after macOS killed the repeated annual graph under extreme compressed-memory pressure. See `plans/milestone-14-time-vectorization.md` and `experiments/m14_time_vectorization/M14B_PROTOCOL.md`. | +| 14 — Time-vectorized multistep formulations | 🟧 M14b open / blocking | M14a's frozen legacy baseline and M14a.1's formulation-specific leaf-bound qualification are complete. M14b is implementing the explicit time-last tensor assembly mode using SCIPY canonicalization alongside the retained stepwise/CPP path. Lossy DC and single-node DC may use the qualified generator/network leaf boxes; storage, nondispatchable, and load-shedding boxes—and lossy-DC HVDC boxes—require focused convex qualification, while AC permits no new leaf-bound migration. Vectorized lossy DC remains the first delivery and blocks resumption of the Case118 annual S4 outer solve after macOS killed the repeated annual graph under extreme compressed-memory pressure. See `plans/milestone-14-time-vectorization.md` and `experiments/m14_time_vectorization/M14B_PROTOCOL.md`. | | 15 — Full lossy HVDC (sign-switching converter losses) | 🔲 Future | charge/discharge-style split of `p_in`; adds fixed converter loss (`LOSS0`); enables losses in `free` and zero-straddling `band` steps; reactive-power support proposed. See `plans/milestone-15-full-lossy-hvdc.md`. | | 16 — Unify grid component model patterns | ✅ Complete | Generators, storage, nondispatchable units, and HVDC share formulation-specific injection and operating-set APIs, temporal coupling slots, and device-owned cost boundaries. Includes first-class `DispatchableGenerator`, MATPOWER fallback, stable identity for external ND/HVDC tables, and collapsed singlenode reuse. See `plans/milestone-16-unify-components.md` and `memories/M16-in-flight-record.md`. | | 17 — Hierarchical DC→AC receding-horizon dispatch | ✅ Complete | The capstone controller passes **identity-aligned SoC signposts only** (not other setpoints) from long-horizon `lossy_dc` planning into short AC-OPF windows, executes only residual-checked target-conditioned first actions, supports causal shifted initialization with audited recovery, and retains the complete plan/attempt tree. M17 fixes the validated `lossy_dc`→`ac` workflow; configurable formulations and additional layers are M21. See `plans/milestone-17-hierarchical-dc-ac.md`. | diff --git a/experiments/m14_time_vectorization/M14B_PROTOCOL.md b/experiments/m14_time_vectorization/M14B_PROTOCOL.md index 408a5dc..127a9f9 100644 --- a/experiments/m14_time_vectorization/M14B_PROTOCOL.md +++ b/experiments/m14_time_vectorization/M14B_PROTOCOL.md @@ -34,6 +34,9 @@ Every prepared field declares one of `static`, `interval`, or `boundary`. Static data remain native-size and may be exposed through zero-stride broadcast views. Interval data append `T`; boundary data append `T + 1`. Temporal class is schema-owned and is never inferred from coincidentally constant values. +Lower and upper box faces declare temporal class independently; mixed boxes +retain a zero-stride static face while moving only the dynamic face from +time-first input to time-last model layout. The vectorized path uses SCIPY canonicalization. The stepwise path continues to use CPP. Backend selection is explicit provenance, not an automatic heuristic. @@ -47,17 +50,19 @@ following component boxes are not implicitly covered: |---|---|---| | Storage `b` and `soc` | lossy DC and single-node DC separately | lower/upper power and energy faces; recurrence; initial state; equality, shortfall, and soft terminal policies | | Nondispatchable `p_nd` | lossy DC and single-node DC separately | zero, availability-limited, and rating-limited coordinates; time-varying availability; identity alignment | -| HVDC `p_hvdc_in` | lossy DC and single-node DC separately | positive-only, negative-only, zero-straddling, degenerate, and time-varying boxes; unchanged affine loss branch | +| HVDC `p_hvdc_in` | lossy DC only | positive-only, negative-only, zero-straddling, degenerate, and time-varying boxes; unchanged affine loss branch | | `load_shed_fraction` | lossy DC and single-node DC separately | ineligible zero-width entries; binding upper faces; time-varying eligibility; served-load and cost reconstruction | Until its gate passes, each family uses explicit vectorized inequalities. A failed or neutral leaf-bound result does not block M14b: explicit inequalities are a valid vectorized representation. -AC component boxes remain explicit during M14. AC storage and inverter circles, -branch apparent-power limits, network equations, storage recurrence and -terminal obligations, and HVDC coupling are coupled or equality constraints, -not leaf-bound candidates. +AC component boxes remain explicit during M14. AC storage real power is part of +the coupled `b`/`b_q` inverter circle and is not itself a box. Single-node HVDC +is an intentional null capability and has no variable to qualify. Inverter +circles, branch apparent-power limits, network equations, storage recurrence +and terminal obligations, and HVDC coupling are coupled or equality +constraints, not leaf-bound candidates. Each focused gate must compare explicit and leaf encodings with identical prepared arrays, equations, costs, solver configuration, and SCIPY backend. It diff --git a/plans/milestone-14-time-vectorization.md b/plans/milestone-14-time-vectorization.md index 27150d1..22b4a14 100644 --- a/plans/milestone-14-time-vectorization.md +++ b/plans/milestone-14-time-vectorization.md @@ -204,8 +204,11 @@ For a variable with logical shape `native_shape + (T,)` or the variable dimensions; - interval- or boundary-varying bounds use their complete time-last arrays directly; and -- lower and upper bounds are validated for finiteness, identity alignment, - exact shape, and elementwise ordering before variable construction. +- lower and upper faces declare temporal class independently, so a static zero + face can remain a zero-stride view while the opposite face varies by + interval or boundary; and +- both faces are validated for finiteness, identity alignment, exact target + shape, and elementwise ordering before variable construction. Candidate applications include independent generator active/reactive limits, bus-voltage boxes, DC storage real-power boxes, nondispatchable @@ -365,17 +368,19 @@ qualification before they may use leaf attributes in a vectorized builder: | Component box | Required probe | Default until qualified | |---|---|---| -| Storage DC real power and all-formulation SoC | Both power faces, both SoC faces, recurrence, initial state, and equality/shortfall/soft terminal behavior | Explicit inequalities | +| Storage real power and SoC in lossy DC and single-node DC | Both power faces, both SoC faces, recurrence, initial state, and equality/shortfall/soft terminal behavior | Explicit inequalities | | Nondispatchable real power | Zero availability, availability-limited and rating-limited coordinates, and time-varying availability with identity alignment | Explicit inequalities | -| HVDC from-terminal power | Positive-only, negative-only, zero-straddling, degenerate, and time-varying boxes while preserving the selected affine loss coupling | Explicit inequalities | +| HVDC from-terminal power in lossy DC | Positive-only, negative-only, zero-straddling, degenerate, and time-varying boxes while preserving the selected affine loss coupling | Explicit inequalities | | Load-shed fraction | Zero-width ineligible entries, active upper faces, time-varying eligibility, served-load reconstruction, and shedding cost | Explicit inequalities | -Lossy DC and single-node DC qualify independently even when their component -equations are shared. AC component boxes remain explicit for M14 regardless of -convex probe results unless a later production-structure DNLP gate explicitly -changes that decision. Coupled apparent-power circles, storage recurrence and -terminal constraints, HVDC loss equalities, and network equations are not -boxes and are never candidates for leaf-bound replacement. +Lossy DC and single-node DC qualify independently where the component is active, +even when their equations are shared. Single-node HVDC is an intentional null +capability and has no box to qualify. AC component boxes remain explicit for +M14 regardless of convex probe results unless a later production-structure +DNLP gate explicitly changes that decision. AC storage real power belongs to +the coupled `b`/`b_q` apparent-power circle rather than an independent box. +Coupled circles, storage recurrence and terminal constraints, HVDC loss +equalities, and network equations are never candidates for leaf bounds. These focused probes are small deterministic M14b gates, not new scaling studies. Each compares explicit and leaf representations through binding diff --git a/src/cvxopf/_component_adapter.py b/src/cvxopf/_component_adapter.py index 4dd796b..95afe56 100644 --- a/src/cvxopf/_component_adapter.py +++ b/src/cvxopf/_component_adapter.py @@ -14,7 +14,6 @@ from types import MappingProxyType from typing import ( Generic, - Literal, Mapping, Protocol, Sequence, @@ -23,8 +22,10 @@ import cvxpy as cp +from cvxopf._temporal_assembly import Formulation as Formulation +from cvxopf._temporal_assembly import HorizonVariableSpec + -Formulation = Literal["ac", "lossy_dc", "singlenode_dc"] UnitT = TypeVar("UnitT") UnitT_contra = TypeVar("UnitT_contra", contravariant=True) InputT = TypeVar("InputT") @@ -70,11 +71,7 @@ class PreparationContext: def __post_init__(self) -> None: _validate_positive_real("base_mva", self.base_mva) - if ( - not isinstance(self.nb, int) - or isinstance(self.nb, bool) - or self.nb <= 0 - ): + if not isinstance(self.nb, int) or isinstance(self.nb, bool) or self.nb <= 0: raise ValueError("nb must be a positive integer") if ( not isinstance(self.horizon_steps, int) @@ -84,14 +81,10 @@ def __post_init__(self) -> None: raise ValueError("horizon_steps must be a positive integer") _validate_positive_real("delta", self.delta) if self.horizon_steps > 1 and self.is_multistep is False: - raise ValueError( - "is_multistep must be True when horizon_steps > 1" - ) + raise ValueError("is_multistep must be True when horizon_steps > 1") object.__setattr__(self, "ext_to_int", _readonly(self.ext_to_int)) if self.is_multistep is None: - object.__setattr__( - self, "is_multistep", self.horizon_steps > 1 - ) + object.__setattr__(self, "is_multistep", self.horizon_steps > 1) @dataclass(frozen=True) @@ -103,9 +96,7 @@ class ACNetworkState: enforce_vset: bool def __post_init__(self) -> None: - object.__setattr__( - self, "controlled_buses", tuple(self.controlled_buses) - ) + object.__setattr__(self, "controlled_buses", tuple(self.controlled_buses)) @dataclass(frozen=True) @@ -134,9 +125,7 @@ def __post_init__(self) -> None: _validate_positive_real("base_mva", self.base_mva) if self.formulation == "ac": if not isinstance(self.network_state, ACNetworkState): - raise ValueError( - "formulation='ac' requires ACNetworkState" - ) + raise ValueError("formulation='ac' requires ACNetworkState") elif not isinstance(self.network_state, DCNetworkState): raise ValueError( f"formulation={self.formulation!r} requires DCNetworkState" @@ -162,6 +151,36 @@ def __post_init__(self) -> None: _validate_positive_real("delta", self.delta) +@dataclass(frozen=True) +class VectorizedContext: + """Typed network and horizon state for one vectorized component build.""" + + formulation: Formulation + horizon_steps: int + delta: float + base_mva: float + ext_to_int: Mapping[int, int] + network_state: NetworkState + + def __post_init__(self) -> None: + if ( + not isinstance(self.horizon_steps, int) + or isinstance(self.horizon_steps, bool) + or self.horizon_steps <= 0 + ): + raise ValueError("horizon_steps must be a positive integer") + _validate_positive_real("delta", self.delta) + _validate_positive_real("base_mva", self.base_mva) + if self.formulation == "ac": + if not isinstance(self.network_state, ACNetworkState): + raise ValueError("formulation='ac' requires ACNetworkState") + elif not isinstance(self.network_state, DCNetworkState): + raise ValueError( + f"formulation={self.formulation!r} requires DCNetworkState" + ) + object.__setattr__(self, "ext_to_int", _readonly(self.ext_to_int)) + + @dataclass(frozen=True) class VariableSpec: """Declarative request for a builder-owned CVXPY variable.""" @@ -248,6 +267,37 @@ def __post_init__(self) -> None: object.__setattr__(self, "expressions", _readonly(self.expressions)) +@dataclass(frozen=True) +class VectorizedModelContribution: + """One component's complete time-last model contribution.""" + + injection: InjectionContribution + operating_constraints: tuple[cp.Constraint, ...] = () + network_constraints: tuple[cp.Constraint, ...] = () + stage_cost_rate: cp.Expression | None = None + expressions: Mapping[str, cp.Expression] = field(default_factory=dict) + horizon: HorizonContribution = field(default_factory=HorizonContribution) + + def __post_init__(self) -> None: + object.__setattr__( + self, "operating_constraints", tuple(self.operating_constraints) + ) + object.__setattr__(self, "network_constraints", tuple(self.network_constraints)) + object.__setattr__(self, "expressions", _readonly(self.expressions)) + + +@dataclass(frozen=True) +class VectorizedComponentContribution: + """Builder-owned variables paired with one vectorized model payload.""" + + variables: Mapping[str, cp.Variable] + model: VectorizedModelContribution + cost_expression_name: str | None = None + + def __post_init__(self) -> None: + object.__setattr__(self, "variables", _readonly(self.variables)) + + class PrepareHook(Protocol[UnitT_contra, InputT_contra]): """Validate and vectorize one component collection.""" @@ -340,6 +390,29 @@ def __call__( ) -> HorizonContribution: ... +class VectorizedVariableSpecHook(Protocol[UnitT_contra]): + """Describe builder-owned time-last variables once per horizon.""" + + def __call__( + self, + units: Sequence[UnitT_contra], + prepared: Mapping[str, object], + context: VectorizedContext, + ) -> tuple[HorizonVariableSpec, ...]: ... + + +class VectorizedAssemblyHook(Protocol[UnitT_contra]): + """Build one component's complete horizon contribution exactly once.""" + + def __call__( + self, + units: Sequence[UnitT_contra], + prepared: Mapping[str, object], + variables: Mapping[str, cp.Variable], + context: VectorizedContext, + ) -> VectorizedModelContribution: ... + + @dataclass(frozen=True) class FormulationAdapter(Generic[UnitT]): """Explicit component hooks for one formulation capability.""" @@ -352,6 +425,8 @@ class FormulationAdapter(Generic[UnitT]): step_cost: StepCostHook[UnitT] | None = None step_expressions: StepExpressionHook[UnitT] | None = None horizon: HorizonHook[UnitT] | None = None + vectorized_variable_specs: VectorizedVariableSpecHook[UnitT] | None = None + vectorized_assembly: VectorizedAssemblyHook[UnitT] | None = None def __post_init__(self) -> None: required = ( @@ -366,6 +441,12 @@ def __post_init__(self) -> None: "active formulation adapters require variable, injection, " "operating-constraint, and horizon hooks" ) + if (self.vectorized_variable_specs is None) != ( + self.vectorized_assembly is None + ): + raise ValueError( + "vectorized variable and assembly hooks must be defined together" + ) elif any( hook is not None for hook in ( @@ -373,6 +454,8 @@ def __post_init__(self) -> None: self.network_constraints, self.step_cost, self.step_expressions, + self.vectorized_variable_specs, + self.vectorized_assembly, ) ): raise ValueError( @@ -393,25 +476,18 @@ class ComponentAdapter(Generic[UnitT, InputT]): def __post_init__(self) -> None: if not self.name: raise ValueError("component adapter name must be nonempty") - if ( - self.cost_expression_name is not None - and ( - not isinstance(self.cost_expression_name, str) - or not self.cost_expression_name - ) + if self.cost_expression_name is not None and ( + not isinstance(self.cost_expression_name, str) + or not self.cost_expression_name ): - raise ValueError( - "component cost expression name must be a nonempty string" - ) + raise ValueError("component cost expression name must be a nonempty string") expected = {"ac", "lossy_dc", "singlenode_dc"} if set(self.formulations) != expected: raise ValueError( "component adapter formulations must contain exactly " f"{sorted(expected)}" ) - object.__setattr__( - self, "formulations", _readonly(self.formulations) - ) + object.__setattr__(self, "formulations", _readonly(self.formulations)) @dataclass(frozen=True) diff --git a/src/cvxopf/_component_assembly.py b/src/cvxopf/_component_assembly.py index a65f9cf..b3a94a5 100644 --- a/src/cvxopf/_component_assembly.py +++ b/src/cvxopf/_component_assembly.py @@ -27,6 +27,9 @@ PreparedComponent, StepContext, StepContribution, + VectorizedComponentContribution, + VectorizedContext, + VectorizedModelContribution, _validate_positive_real, bind_injection_scale, ) @@ -101,9 +104,7 @@ def prepare_components( if binding.capability is FormulationCapability.NULL: prepared_data = {} else: - prepared_data = adapter.prepare( - request.units, request.inputs, context - ) + prepared_data = adapter.prepare(request.units, request.inputs, context) overlap = set(flat_data).intersection(prepared_data) if overlap: raise ValueError( @@ -146,9 +147,8 @@ def _validate_step_variable_schemas( first = step_contributions[0] component_names = tuple(first) component_name_set = set(component_names) - if ( - expected_components is not None - and component_name_set != set(expected_components) + if expected_components is not None and component_name_set != set( + expected_components ): raise ValueError( "step 0 component keys do not match the prepared registry: " @@ -172,8 +172,9 @@ def _validate_step_variable_schemas( for component_name in component_names: actual_schema = { variable_name: variable.shape - for variable_name, variable - in contributions[component_name].variables.items() + for variable_name, variable in contributions[ + component_name + ].variables.items() } if actual_schema != variable_schemas[component_name]: raise ValueError( @@ -188,7 +189,7 @@ def _validate_injection_contribution( contribution: InjectionContribution, *, formulation: Formulation, - nb: int, + expected_shape: tuple[int, ...], ) -> None: """Enforce exact nodal-channel shapes and formulation channel support.""" if formulation != "ac" and contribution.q_pu is not None: @@ -196,7 +197,6 @@ def _validate_injection_contribution( f"component {component_name!r} returned a reactive injection " f"for formulation {formulation!r}; q_pu must be None" ) - expected_shape = (nb,) for channel_name, expression in ( ("p_pu", contribution.p_pu), ("q_pu", contribution.q_pu), @@ -220,8 +220,7 @@ def _validate_injection_contribution( return if not isinstance(parameter, cp.Parameter): raise ValueError( - f"component {component_name!r} inv_base_mva must be " - "a scalar cp.Parameter" + f"component {component_name!r} inv_base_mva must be a scalar cp.Parameter" ) if parameter.shape != (): raise ValueError( @@ -256,13 +255,9 @@ def assemble_component_step( "step formulation does not match prepared component formulation" ) if context.base_mva != prepared.context.base_mva: - raise ValueError( - "step base_mva does not match component preparation" - ) + raise ValueError("step base_mva does not match component preparation") if context.ext_to_int != prepared.context.ext_to_int: - raise ValueError( - "step ext_to_int does not match component preparation" - ) + raise ValueError("step ext_to_int does not match component preparation") if context.step >= prepared.context.horizon_steps: raise ValueError( f"step index {context.step} is outside prepared horizon " @@ -286,21 +281,14 @@ def assemble_component_step( assert binding.injections is not None assert binding.operating_constraints is not None assert binding.horizon is not None - specs = binding.variable_specs( - component.units, component.data, context - ) + specs = binding.variable_specs(component.units, component.data, context) variable_names = [spec.name for spec in specs] duplicate_names = sorted( - { - name - for name in variable_names - if variable_names.count(name) > 1 - } + {name for name in variable_names if variable_names.count(name) > 1} ) if duplicate_names: raise ValueError( - f"component {name!r} requested duplicate variables: " - f"{duplicate_names}" + f"component {name!r} requested duplicate variables: {duplicate_names}" ) variables = { spec.name: cp.Variable( @@ -317,7 +305,7 @@ def assemble_component_step( name, injection, formulation=context.formulation, - nb=prepared.context.nb, + expected_shape=(prepared.context.nb,), ) bind_injection_scale(injection, context.base_mva) operating_constraints = binding.operating_constraints( @@ -333,9 +321,7 @@ def assemble_component_step( cost = ( None if binding.step_cost is None - else binding.step_cost( - component.units, component.data, variables, context - ) + else binding.step_cost(component.units, component.data, variables, context) ) expressions = ( {} @@ -358,6 +344,162 @@ def assemble_component_step( return MappingProxyType(contributions) +def _validate_vectorized_model_contribution( + component_name: str, + model: VectorizedModelContribution, + *, + context: VectorizedContext, + nb: int, +) -> None: + """Enforce time-last shapes and the device-layer DCP boundary.""" + _validate_injection_contribution( + component_name, + model.injection, + formulation=context.formulation, + expected_shape=(nb, context.horizon_steps), + ) + for channel_name, expression in ( + ("p_pu", model.injection.p_pu), + ("q_pu", model.injection.q_pu), + ): + if expression is not None and not expression.is_affine(): + raise ValueError( + f"component {component_name!r} vectorized injection " + f"{channel_name} must be affine" + ) + if model.stage_cost_rate is not None: + if model.stage_cost_rate.shape != (context.horizon_steps,): + raise ValueError( + f"component {component_name!r} stage cost rate must have " + f"shape ({context.horizon_steps},), got " + f"{model.stage_cost_rate.shape}" + ) + if not model.stage_cost_rate.is_convex(): + raise ValueError( + f"component {component_name!r} stage cost rate must be convex" + ) + constraints = ( + *model.operating_constraints, + *model.network_constraints, + *model.horizon.constraints, + ) + if any(not constraint.is_dcp() for constraint in constraints): + raise ValueError( + f"component {component_name!r} vectorized constraints must be DCP" + ) + if model.horizon.terminal_cost is not None and ( + not model.horizon.terminal_cost.is_scalar() + or not model.horizon.terminal_cost.is_convex() + ): + raise ValueError( + f"component {component_name!r} terminal cost must be scalar convex" + ) + _validate_expression_names(component_name, model.expressions, horizon=False) + for expression_name, expression in model.expressions.items(): + if not isinstance(expression, cp.Expression): + raise ValueError( + f"component {component_name!r} expression " + f"{expression_name!r} must be a cp.Expression" + ) + if expression.ndim == 0 or expression.shape[-1] != context.horizon_steps: + raise ValueError( + f"component {component_name!r} expression " + f"{expression_name!r} must have final axis " + f"{context.horizon_steps}, got {expression.shape}" + ) + _validate_expression_names(component_name, model.horizon.expressions, horizon=True) + for expression_name, expression in model.horizon.expressions.items(): + if not isinstance(expression, cp.Expression): + raise ValueError( + f"component {component_name!r} horizon expression " + f"{expression_name!r} must be a cp.Expression" + ) + + +def assemble_component_vectorized( + prepared: PreparedComponents, + context: VectorizedContext, +) -> Mapping[str, VectorizedComponentContribution]: + """Assemble each component exactly once over a time-last horizon.""" + if context.formulation != prepared.formulation: + raise ValueError("vectorized formulation does not match component preparation") + if context.horizon_steps != prepared.context.horizon_steps: + raise ValueError( + "vectorized horizon_steps does not match component preparation" + ) + if context.delta != prepared.context.delta: + raise ValueError("vectorized delta does not match preparation") + if context.base_mva != prepared.context.base_mva: + raise ValueError("vectorized base_mva does not match preparation") + if context.ext_to_int != prepared.context.ext_to_int: + raise ValueError("vectorized ext_to_int does not match preparation") + + contributions: dict[str, VectorizedComponentContribution] = {} + for name, component in prepared.components.items(): + binding = component.adapter.formulations[context.formulation] + if binding.capability is FormulationCapability.NULL: + contributions[name] = VectorizedComponentContribution( + variables={}, + model=VectorizedModelContribution( + injection=InjectionContribution(None, None) + ), + ) + continue + if binding.capability is not FormulationCapability.ACTIVE: + raise ValueError( + f"component {name!r} is not active for " + f"formulation {context.formulation!r}" + ) + if ( + binding.vectorized_variable_specs is None + or binding.vectorized_assembly is None + ): + raise ValueError( + f"component {name!r} has no vectorized horizon binding for " + f"formulation {context.formulation!r}" + ) + specs = binding.vectorized_variable_specs( + component.units, component.data, context + ) + names = [spec.name for spec in specs] + duplicates = sorted( + {variable_name for variable_name in names if names.count(variable_name) > 1} + ) + if duplicates: + raise ValueError( + f"component {name!r} requested duplicate vectorized " + f"variables: {duplicates}" + ) + variables = { + spec.name: cp.Variable( + spec.shape(context.horizon_steps), + name=spec.name, + **spec.attributes, + ) + for spec in specs + } + model = binding.vectorized_assembly( + component.units, component.data, variables, context + ) + _validate_vectorized_model_contribution( + name, + model, + context=context, + nb=prepared.context.nb, + ) + bind_injection_scale(model.injection, context.base_mva) + contributions[name] = VectorizedComponentContribution( + variables=variables, + model=model, + cost_expression_name=( + None + if model.stage_cost_rate is None + else component.adapter.cost_expression_name + ), + ) + return MappingProxyType(contributions) + + def assemble_component_horizon( prepared: PreparedComponents, step_contributions: Sequence[Mapping[str, StepContribution]], @@ -369,15 +511,11 @@ def assemble_component_horizon( "horizon formulation does not match prepared component formulation" ) if context.horizon_steps != prepared.context.horizon_steps: - raise ValueError( - "horizon_steps does not match component preparation" - ) + raise ValueError("horizon_steps does not match component preparation") if context.delta != prepared.context.delta: raise ValueError("horizon delta does not match component preparation") if len(step_contributions) != context.horizon_steps: - raise ValueError( - "step contribution count must equal horizon_steps" - ) + raise ValueError("step contribution count must equal horizon_steps") _validate_step_variable_schemas( step_contributions, expected_components=tuple(prepared.components), @@ -392,8 +530,7 @@ def assemble_component_horizon( variable_names = step_contributions[0][name].variables variable_history = { variable_name: [ - step[name].variables[variable_name] - for step in step_contributions + step[name].variables[variable_name] for step in step_contributions ] for variable_name in variable_names } @@ -418,9 +555,7 @@ def aggregate_step_contributions( costs: list[cp.Expression] = [] expressions: dict[str, cp.Expression] = {} for name, contribution in contributions.items(): - duplicate_variables = set(variables).intersection( - contribution.variables - ) + duplicate_variables = set(variables).intersection(contribution.variables) if duplicate_variables: raise ValueError( f"component {name!r} published duplicate variables: " @@ -439,16 +574,11 @@ def aggregate_step_contributions( or not contribution.cost.is_scalar() ): raise ValueError( - f"component {name!r} step cost must be a scalar " - "cp.Expression" + f"component {name!r} step cost must be a scalar cp.Expression" ) costs.append(contribution.cost) - _validate_expression_names( - name, contribution.expressions, horizon=False - ) - duplicate_expressions = set(expressions).intersection( - contribution.expressions - ) + _validate_expression_names(name, contribution.expressions, horizon=False) + duplicate_expressions = set(expressions).intersection(contribution.expressions) if duplicate_expressions: raise ValueError( f"component {name!r} published duplicate expressions: " @@ -505,16 +635,11 @@ def aggregate_horizon_contributions( or not contribution.terminal_cost.is_scalar() ): raise ValueError( - f"component {name!r} terminal cost must be a scalar " - "cp.Expression" + f"component {name!r} terminal cost must be a scalar cp.Expression" ) terminal_costs.append(contribution.terminal_cost) - _validate_expression_names( - name, contribution.expressions, horizon=True - ) - duplicate_expressions = set(expressions).intersection( - contribution.expressions - ) + _validate_expression_names(name, contribution.expressions, horizon=True) + duplicate_expressions = set(expressions).intersection(contribution.expressions) if duplicate_expressions: raise ValueError( f"component {name!r} published duplicate horizon expressions: " @@ -547,8 +672,7 @@ def integrate_stage_cost_rates( for index, rate in enumerate(stage_cost_rates): if not isinstance(rate, cp.Expression) or not rate.is_scalar(): raise ValueError( - f"stage cost rate at index {index} must be a scalar " - "cp.Expression" + f"stage cost rate at index {index} must be a scalar cp.Expression" ) summed_rate = cast( cp.Expression, @@ -565,9 +689,7 @@ def integrate_component_stage_costs( _validate_step_variable_schemas(step_contributions) costs: dict[str, cp.Expression] = {} for component_name in step_contributions[0]: - rates = [ - step[component_name].cost for step in step_contributions - ] + rates = [step[component_name].cost for step in step_contributions] if all(rate is None for rate in rates): continue if any(rate is None for rate in rates): @@ -576,8 +698,7 @@ def integrate_component_stage_costs( "availability across the horizon" ) names = { - step[component_name].cost_expression_name - for step in step_contributions + step[component_name].cost_expression_name for step in step_contributions } if len(names) != 1: raise ValueError( @@ -604,9 +725,7 @@ def _validate_publication_step_count( ) -> None: """Enforce the shared single- versus multistep publication cardinality.""" if step_count == 0: - raise ValueError( - "publication requires at least one step contribution" - ) + raise ValueError("publication requires at least one step contribution") if not multistep and step_count != 1: raise ValueError( "single-step publication requires exactly one step " @@ -615,9 +734,7 @@ def _validate_publication_step_count( def _validate_formulation_variable_schema( - formulation_variables: Mapping[ - str, cp.Variable | list[cp.Variable] - ], + formulation_variables: Mapping[str, cp.Variable | list[cp.Variable]], *, step_count: int, multistep: bool, @@ -627,8 +744,7 @@ def _validate_formulation_variable_schema( if not multistep: if not isinstance(value, cp.Variable): raise ValueError( - f"single-step formulation variable {name!r} must be " - "a cp.Variable" + f"single-step formulation variable {name!r} must be a cp.Variable" ) continue if not isinstance(value, list): @@ -650,16 +766,12 @@ def _validate_formulation_variable_schema( def publish_component_variables( step_contributions: Sequence[Mapping[str, StepContribution]], - formulation_variables: Mapping[ - str, cp.Variable | list[cp.Variable] - ] | None = None, + formulation_variables: Mapping[str, cp.Variable | list[cp.Variable]] | None = None, *, multistep: bool, ) -> dict[str, cp.Variable | list[cp.Variable]]: """Merge component variables into the formulation-owned build schema.""" - _validate_publication_step_count( - len(step_contributions), multistep=multistep - ) + _validate_publication_step_count(len(step_contributions), multistep=multistep) formulation_variables = ( {} if formulation_variables is None else formulation_variables ) @@ -678,8 +790,7 @@ def publish_component_variables( "collides with an already published variable" ) published[variable_name] = ( - [step[name].variables[variable_name] - for step in step_contributions] + [step[name].variables[variable_name] for step in step_contributions] if multistep else variable ) @@ -691,16 +802,12 @@ def publish_component_metadata( formulation_metadata: Mapping[str, object] | None = None, ) -> dict[str, object]: """Merge active component metadata into the formulation-owned data.""" - published = ( - {} if formulation_metadata is None else dict(formulation_metadata) - ) + published = {} if formulation_metadata is None else dict(formulation_metadata) for name, component in prepared.components.items(): binding = component.adapter.formulations[prepared.formulation] if binding.capability is FormulationCapability.NULL: continue - metadata = component.adapter.metadata( - component.data, prepared.formulation - ) + metadata = component.adapter.metadata(component.data, prepared.formulation) overlap = set(published).intersection(metadata) if overlap: raise ValueError( @@ -714,9 +821,7 @@ def publish_component_metadata( def publish_component_expressions( step_aggregates: Sequence[StepContribution], horizon_contribution: HorizonContribution, - compatibility_expressions: Mapping[ - str, cp.Expression | list[cp.Expression] - ], + compatibility_expressions: Mapping[str, cp.Expression | list[cp.Expression]], *, multistep: bool, ) -> dict[str, cp.Expression | list[cp.Expression]]: @@ -727,12 +832,8 @@ def publish_component_expressions( may collide with another contribution or with a formulation-owned compatibility expression. """ - _validate_publication_step_count( - len(step_aggregates), multistep=multistep - ) - step_expressions = [ - aggregate.expressions for aggregate in step_aggregates - ] + _validate_publication_step_count(len(step_aggregates), multistep=multistep) + step_expressions = [aggregate.expressions for aggregate in step_aggregates] expression_names = tuple(step_expressions[0]) expected_names = set(expression_names) for step, expressions in enumerate(step_expressions[1:], start=1): @@ -757,9 +858,7 @@ def publish_component_expressions( else step_expressions[0][name] ) - horizon_collisions = set(published).intersection( - horizon_contribution.expressions - ) + horizon_collisions = set(published).intersection(horizon_contribution.expressions) if horizon_collisions: raise ValueError( "horizon expressions collide with published expressions: " diff --git a/src/cvxopf/_temporal_assembly.py b/src/cvxopf/_temporal_assembly.py new file mode 100644 index 0000000..7571ef5 --- /dev/null +++ b/src/cvxopf/_temporal_assembly.py @@ -0,0 +1,359 @@ +"""Typed internal contracts for horizon-vectorized model assembly. + +This module contains representation mechanics only. It does not own component +physics or formulation equations. The public stepwise builders remain the +default while M14b composes these contracts into the vectorized path. +""" + +from __future__ import annotations + +from dataclasses import dataclass, field +from enum import Enum +from types import MappingProxyType +from typing import Literal, Mapping + +import numpy as np + +Formulation = Literal["ac", "lossy_dc", "singlenode_dc"] +TemporalClass = Literal["static", "interval", "boundary"] +BoxRepresentation = Literal["explicit", "leaf"] +BoxDecisionAuthority = Literal[ + "m14a1_qualified", + "existing_production", + "pending_component_gate", + "ac_explicit_policy", +] + + +def _validate_horizon_steps(horizon_steps: int) -> None: + if ( + not isinstance(horizon_steps, int) + or isinstance(horizon_steps, bool) + or horizon_steps <= 0 + ): + raise ValueError("horizon_steps must be a positive integer") + + +def _validate_native_shape(native_shape: tuple[int, ...], *, allow_zero: bool) -> None: + if any( + not isinstance(dimension, int) + or isinstance(dimension, bool) + or dimension < (0 if allow_zero else 1) + for dimension in native_shape + ): + qualifier = "nonnegative" if allow_zero else "positive" + raise ValueError(f"native_shape dimensions must be {qualifier} integers") + + +@dataclass(frozen=True) +class TemporalFieldSpec: + """One schema-owned static, interval, or boundary model field.""" + + name: str + native_shape: tuple[int, ...] + temporal_class: TemporalClass + + def __post_init__(self) -> None: + if not self.name: + raise ValueError("temporal field name must be nonempty") + _validate_native_shape(self.native_shape, allow_zero=True) + if self.temporal_class not in {"static", "interval", "boundary"}: + raise ValueError(f"invalid temporal class {self.temporal_class!r}") + + def internal_shape(self, horizon_steps: int) -> tuple[int, ...]: + """Return the native or time-last internal shape.""" + _validate_horizon_steps(horizon_steps) + if self.temporal_class == "static": + return self.native_shape + extra = horizon_steps + (self.temporal_class == "boundary") + return self.native_shape + (extra,) + + def public_shape(self, horizon_steps: int) -> tuple[int, ...]: + """Return the retained time-first public input/result shape.""" + _validate_horizon_steps(horizon_steps) + if self.temporal_class == "static": + return self.native_shape + extra = horizon_steps + (self.temporal_class == "boundary") + return (extra,) + self.native_shape + + def to_internal(self, values: np.ndarray, horizon_steps: int) -> np.ndarray: + """Validate one public array and move its temporal axis exactly once.""" + array = np.asarray(values) + expected = self.public_shape(horizon_steps) + if array.shape != expected: + raise ValueError( + f"field {self.name!r} must have public shape {expected}, " + f"got {array.shape}" + ) + if self.temporal_class == "static": + return array + return np.moveaxis(array, 0, -1) + + def to_public(self, values: np.ndarray, horizon_steps: int) -> np.ndarray: + """Validate one internal array and restore its public time-first axis.""" + array = np.asarray(values) + expected = self.internal_shape(horizon_steps) + if array.shape != expected: + raise ValueError( + f"field {self.name!r} must have internal shape {expected}, " + f"got {array.shape}" + ) + if self.temporal_class == "static": + return array + return np.moveaxis(array, -1, 0) + + +@dataclass(frozen=True) +class HorizonVariableSpec: + """Declarative schema for one interval or boundary CVXPY variable.""" + + name: str + native_shape: tuple[int, ...] + temporal_class: Literal["interval", "boundary"] = "interval" + attributes: Mapping[str, object] = field(default_factory=dict) + + def __post_init__(self) -> None: + if not self.name: + raise ValueError("horizon variable name must be nonempty") + _validate_native_shape(self.native_shape, allow_zero=False) + if self.temporal_class not in {"interval", "boundary"}: + raise ValueError("horizon variables must be interval or boundary") + object.__setattr__(self, "attributes", MappingProxyType(dict(self.attributes))) + + def shape(self, horizon_steps: int) -> tuple[int, ...]: + """Return the variable's time-last horizon shape.""" + return TemporalFieldSpec( + self.name, self.native_shape, self.temporal_class + ).internal_shape(horizon_steps) + + +def broadcast_static_bound( + values: np.ndarray | float, + *, + native_shape: tuple[int, ...], + horizon_steps: int, + temporal_class: Literal["interval", "boundary"] = "interval", +) -> np.ndarray: + """Expose static bound data at exact time-last shape without tiling it.""" + _validate_native_shape(native_shape, allow_zero=False) + _validate_horizon_steps(horizon_steps) + if temporal_class not in {"interval", "boundary"}: + raise ValueError("bound temporal class must be interval or boundary") + source = np.asarray(values) + if source.shape != native_shape: + raise ValueError( + f"static bound must have native shape {native_shape}, got {source.shape}" + ) + extra = horizon_steps + (temporal_class == "boundary") + return np.broadcast_to(source[..., np.newaxis], native_shape + (extra,)) + + +@dataclass(frozen=True) +class PreparedBoxBounds: + """Validated lower/upper arrays at one exact horizon-variable shape.""" + + lower: np.ndarray + upper: np.ndarray + + def __post_init__(self) -> None: + if self.lower.shape != self.upper.shape: + raise ValueError("prepared lower and upper bounds must align") + if self.lower.flags.writeable or self.upper.flags.writeable: + raise ValueError("prepared bounds must be read-only") + + +def _prepare_box_face( + values: np.ndarray | float, + *, + face_name: Literal["lower", "upper"], + native_shape: tuple[int, ...], + horizon_steps: int, + data_temporal_class: TemporalClass, + variable_temporal_class: Literal["interval", "boundary"], +) -> np.ndarray: + """Normalize one bound face to the target variable's time-last shape.""" + if variable_temporal_class not in {"interval", "boundary"}: + raise ValueError("box variable temporal class must be interval or boundary") + if data_temporal_class == "static": + internal = broadcast_static_bound( + values, + native_shape=native_shape, + horizon_steps=horizon_steps, + temporal_class=variable_temporal_class, + ) + else: + if data_temporal_class != variable_temporal_class: + raise ValueError( + f"time-varying {face_name} bound data must match the target " + "variable temporal class" + ) + field = TemporalFieldSpec( + f"{face_name} box bound", native_shape, data_temporal_class + ) + internal = field.to_internal(np.asarray(values), horizon_steps) + if not np.all(np.isfinite(internal)): + raise ValueError(f"{face_name} bounds must contain only finite values") + readonly = np.asarray(internal).view() + readonly.flags.writeable = False + return readonly + + +def prepare_box_bounds( + lower: np.ndarray | float, + upper: np.ndarray | float, + *, + native_shape: tuple[int, ...], + horizon_steps: int, + lower_temporal_class: TemporalClass, + upper_temporal_class: TemporalClass, + variable_temporal_class: Literal["interval", "boundary"], +) -> PreparedBoxBounds: + """Normalize independently temporal box faces to one variable shape.""" + lower_internal = _prepare_box_face( + lower, + face_name="lower", + native_shape=native_shape, + horizon_steps=horizon_steps, + data_temporal_class=lower_temporal_class, + variable_temporal_class=variable_temporal_class, + ) + upper_internal = _prepare_box_face( + upper, + face_name="upper", + native_shape=native_shape, + horizon_steps=horizon_steps, + data_temporal_class=upper_temporal_class, + variable_temporal_class=variable_temporal_class, + ) + if np.any(lower_internal > upper_internal): + raise ValueError("lower bounds must not exceed upper bounds") + return PreparedBoxBounds(lower_internal, upper_internal) + + +class VariableBoxFamily(Enum): + """Closed set of independently represented elementwise operating boxes.""" + + DISPATCHABLE_P = "dispatchable_p" + DISPATCHABLE_Q = "dispatchable_q" + AC_VOLTAGE = "ac_voltage" + DC_BRANCH_FLOW = "dc_branch_flow" + STORAGE_REAL_POWER = "storage_real_power" + STORAGE_SOC = "storage_soc" + NONDISPATCHABLE_REAL_POWER = "nondispatchable_real_power" + HVDC_INPUT_POWER = "hvdc_input_power" + LOAD_SHED_FRACTION = "load_shed_fraction" + + +@dataclass(frozen=True) +class BoxRepresentationDecision: + """Frozen representation selected for one formulation/box family.""" + + representation: BoxRepresentation + authority: BoxDecisionAuthority + requires_focused_qualification: bool = False + + +def _decision( + representation: BoxRepresentation, + authority: BoxDecisionAuthority, + *, + pending: bool = False, +) -> BoxRepresentationDecision: + return BoxRepresentationDecision(representation, authority, pending) + + +def _pending_decisions( + formulation: Formulation, + families: tuple[VariableBoxFamily, ...], +) -> dict[tuple[Formulation, VariableBoxFamily], BoxRepresentationDecision]: + return { + (formulation, family): _decision( + "explicit", "pending_component_gate", pending=True + ) + for family in families + } + + +_BOX_REPRESENTATIONS: Mapping[ + tuple[Formulation, VariableBoxFamily], BoxRepresentationDecision +] = MappingProxyType( + { + ("lossy_dc", VariableBoxFamily.DISPATCHABLE_P): _decision( + "leaf", "m14a1_qualified" + ), + ("lossy_dc", VariableBoxFamily.DC_BRANCH_FLOW): _decision( + "leaf", "m14a1_qualified" + ), + ("singlenode_dc", VariableBoxFamily.DISPATCHABLE_P): _decision( + "leaf", "m14a1_qualified" + ), + ("ac", VariableBoxFamily.DISPATCHABLE_P): _decision( + "explicit", "ac_explicit_policy" + ), + ("ac", VariableBoxFamily.DISPATCHABLE_Q): _decision( + "explicit", "ac_explicit_policy" + ), + ("ac", VariableBoxFamily.AC_VOLTAGE): _decision("leaf", "existing_production"), + **_pending_decisions( + "lossy_dc", + ( + VariableBoxFamily.STORAGE_REAL_POWER, + VariableBoxFamily.STORAGE_SOC, + VariableBoxFamily.NONDISPATCHABLE_REAL_POWER, + VariableBoxFamily.HVDC_INPUT_POWER, + VariableBoxFamily.LOAD_SHED_FRACTION, + ), + ), + **_pending_decisions( + "singlenode_dc", + ( + VariableBoxFamily.STORAGE_REAL_POWER, + VariableBoxFamily.STORAGE_SOC, + VariableBoxFamily.NONDISPATCHABLE_REAL_POWER, + VariableBoxFamily.LOAD_SHED_FRACTION, + ), + ), + **{ + ("ac", family): _decision("explicit", "ac_explicit_policy") + for family in ( + VariableBoxFamily.STORAGE_SOC, + VariableBoxFamily.NONDISPATCHABLE_REAL_POWER, + VariableBoxFamily.HVDC_INPUT_POWER, + VariableBoxFamily.LOAD_SHED_FRACTION, + ) + }, + } +) + + +def box_representation_decision( + formulation: Formulation, + family: VariableBoxFamily, +) -> BoxRepresentationDecision: + """Return one frozen decision, rejecting inapplicable combinations.""" + try: + return _BOX_REPRESENTATIONS[(formulation, family)] + except KeyError as error: + raise ValueError( + f"box family {family.value!r} does not apply to formulation {formulation!r}" + ) from error + + +def pending_component_box_families() -> tuple[VariableBoxFamily, ...]: + """Return the component-owned box families requiring focused gates.""" + return ( + VariableBoxFamily.STORAGE_REAL_POWER, + VariableBoxFamily.STORAGE_SOC, + VariableBoxFamily.NONDISPATCHABLE_REAL_POWER, + VariableBoxFamily.HVDC_INPUT_POWER, + VariableBoxFamily.LOAD_SHED_FRACTION, + ) + + +def pending_component_box_pairs() -> tuple[tuple[Formulation, VariableBoxFamily], ...]: + """Return only physically applicable pending formulation/box pairs.""" + return tuple( + pair + for pair, decision in _BOX_REPRESENTATIONS.items() + if decision.requires_focused_qualification + ) diff --git a/tests/test_m14b_temporal_contract.py b/tests/test_m14b_temporal_contract.py new file mode 100644 index 0000000..de64878 --- /dev/null +++ b/tests/test_m14b_temporal_contract.py @@ -0,0 +1,311 @@ +"""Structural tests for the M14b horizon-assembly vocabulary.""" + +import numpy as np +import pytest + +from cvxopf._temporal_assembly import ( + HorizonVariableSpec, + TemporalFieldSpec, + VariableBoxFamily, + box_representation_decision, + broadcast_static_bound, + pending_component_box_families, + pending_component_box_pairs, + prepare_box_bounds, +) + + +@pytest.mark.parametrize( + ("temporal_class", "public_shape", "internal_shape"), + [ + ("static", (2, 3), (2, 3)), + ("interval", (4, 2, 3), (2, 3, 4)), + ("boundary", (5, 2, 3), (2, 3, 5)), + ], +) +def test_temporal_field_shapes_and_axis_round_trip( + temporal_class, public_shape, internal_shape +): + spec = TemporalFieldSpec("field", (2, 3), temporal_class) + public = np.arange(np.prod(public_shape)).reshape(public_shape) + + internal = spec.to_internal(public, 4) + + assert spec.public_shape(4) == public_shape + assert spec.internal_shape(4) == internal_shape + assert internal.shape == internal_shape + assert np.shares_memory(public, internal) + assert np.array_equal(spec.to_public(internal, 4), public) + + +def test_scalar_interval_field_and_boundary_variable_lift_one_axis(): + interval = TemporalFieldSpec("rate", (), "interval") + boundary = HorizonVariableSpec("soc", (3,), "boundary") + + assert interval.internal_shape(7) == (7,) + assert boundary.shape(7) == (3, 8) + + +def test_temporal_field_preserves_explicit_empty_component_axis(): + spec = TemporalFieldSpec("empty_load", (0,), "interval") + public = np.empty((4, 0)) + + internal = spec.to_internal(public, 4) + + assert internal.shape == (0, 4) + assert spec.to_public(internal, 4).shape == public.shape + + +def test_horizon_variable_rejects_zero_sized_axes(): + with pytest.raises(ValueError, match="positive integers"): + HorizonVariableSpec("empty", (0,)) + + +@pytest.mark.parametrize("horizon_steps", [0, -1, True]) +def test_temporal_contract_rejects_invalid_horizons(horizon_steps): + spec = TemporalFieldSpec("field", (2,), "interval") + + with pytest.raises(ValueError, match="positive integer"): + spec.internal_shape(horizon_steps) + + +def test_temporal_contract_rejects_shape_mismatch(): + spec = TemporalFieldSpec("load", (2,), "interval") + + with pytest.raises(ValueError, match="public shape"): + spec.to_internal(np.ones((2, 4)), 4) + + +def test_static_bound_broadcast_is_read_only_zero_stride_view(): + source = np.array([1.0, 2.0, 3.0]) + + bound = broadcast_static_bound(source, native_shape=(3,), horizon_steps=6) + + assert bound.shape == (3, 6) + assert bound.strides[-1] == 0 + assert not bound.flags.writeable + assert np.shares_memory(source, bound) + assert np.array_equal(bound[:, 0], source) + assert np.array_equal(bound[:, -1], source) + + +def test_static_boundary_bound_uses_t_plus_one(): + bound = broadcast_static_bound( + np.array([4.0, 5.0]), + native_shape=(2,), + horizon_steps=3, + temporal_class="boundary", + ) + + assert bound.shape == (2, 4) + + +def test_box_preparation_validates_static_bounds_without_tiling(): + lower = np.array([-2.0, -1.0]) + upper = np.array([3.0, 4.0]) + + prepared = prepare_box_bounds( + lower, + upper, + native_shape=(2,), + horizon_steps=5, + lower_temporal_class="static", + upper_temporal_class="static", + variable_temporal_class="interval", + ) + + assert prepared.lower.shape == prepared.upper.shape == (2, 5) + assert prepared.lower.strides[-1] == prepared.upper.strides[-1] == 0 + assert np.shares_memory(lower, prepared.lower) + assert np.shares_memory(upper, prepared.upper) + assert not prepared.lower.flags.writeable + assert not prepared.upper.flags.writeable + + +def test_box_preparation_moves_interval_axis_once(): + lower = np.arange(6, dtype=float).reshape(3, 2) + upper = lower + 1.0 + + prepared = prepare_box_bounds( + lower, + upper, + native_shape=(2,), + horizon_steps=3, + lower_temporal_class="interval", + upper_temporal_class="interval", + variable_temporal_class="interval", + ) + + assert prepared.lower.shape == prepared.upper.shape == (2, 3) + assert np.array_equal(prepared.lower, lower.T) + assert np.array_equal(prepared.upper, upper.T) + assert np.shares_memory(lower, prepared.lower) + assert np.shares_memory(upper, prepared.upper) + + +@pytest.mark.parametrize( + ("lower", "upper", "message"), + [ + (np.array([np.nan]), np.array([1.0]), "lower bounds"), + (np.array([0.0]), np.array([np.inf]), "upper bounds"), + (np.array([2.0]), np.array([1.0]), "must not exceed"), + ], +) +def test_box_preparation_rejects_nonfinite_or_reversed_bounds(lower, upper, message): + with pytest.raises(ValueError, match=message): + prepare_box_bounds( + lower, + upper, + native_shape=(1,), + horizon_steps=2, + lower_temporal_class="static", + upper_temporal_class="static", + variable_temporal_class="interval", + ) + + +def test_static_soc_bounds_target_t_plus_one_boundary_states_without_tiling(): + capacity = np.array([10.0, 20.0]) + + prepared = prepare_box_bounds( + np.zeros(2), + capacity, + native_shape=(2,), + horizon_steps=4, + lower_temporal_class="static", + upper_temporal_class="static", + variable_temporal_class="boundary", + ) + + assert prepared.lower.shape == prepared.upper.shape == (2, 5) + assert prepared.upper.strides[-1] == 0 + assert np.shares_memory(capacity, prepared.upper) + assert np.array_equal(prepared.upper[:, -1], capacity) + + +def test_dynamic_box_data_must_match_target_variable_temporality(): + with pytest.raises(ValueError, match="must match"): + prepare_box_bounds( + np.zeros((3, 1)), + np.ones((3, 1)), + native_shape=(1,), + horizon_steps=2, + lower_temporal_class="boundary", + upper_temporal_class="boundary", + variable_temporal_class="interval", + ) + + +def test_box_faces_support_mixed_static_and_interval_temporality(): + lower = np.zeros(2) + upper = np.arange(6, dtype=float).reshape(3, 2) + 1.0 + + prepared = prepare_box_bounds( + lower, + upper, + native_shape=(2,), + horizon_steps=3, + lower_temporal_class="static", + upper_temporal_class="interval", + variable_temporal_class="interval", + ) + + assert prepared.lower.shape == prepared.upper.shape == (2, 3) + assert prepared.lower.strides[-1] == 0 + assert np.shares_memory(lower, prepared.lower) + assert np.shares_memory(upper, prepared.upper) + assert np.array_equal(prepared.upper, upper.T) + + +def test_multistep_t1_preserves_interval_and_boundary_axes(): + interval = TemporalFieldSpec("dispatch", (2,), "interval") + boundary = TemporalFieldSpec("state", (2,), "boundary") + interval_public = np.array([[1.0, 2.0]]) + boundary_public = np.array([[3.0, 4.0], [5.0, 6.0]]) + + interval_internal = interval.to_internal(interval_public, 1) + boundary_internal = boundary.to_internal(boundary_public, 1) + + assert interval_internal.shape == (2, 1) + assert boundary_internal.shape == (2, 2) + assert np.array_equal(interval.to_public(interval_internal, 1), interval_public) + assert np.array_equal(boundary.to_public(boundary_internal, 1), boundary_public) + + +@pytest.mark.parametrize( + ("formulation", "family"), + [ + ("lossy_dc", VariableBoxFamily.DISPATCHABLE_P), + ("lossy_dc", VariableBoxFamily.DC_BRANCH_FLOW), + ("singlenode_dc", VariableBoxFamily.DISPATCHABLE_P), + ], +) +def test_m14a1_qualified_convex_boxes_select_leaf(formulation, family): + decision = box_representation_decision(formulation, family) + + assert decision.representation == "leaf" + assert decision.authority == "m14a1_qualified" + assert not decision.requires_focused_qualification + + +def test_existing_ac_voltage_leaf_is_not_blanket_ac_authorization(): + voltage = box_representation_decision("ac", VariableBoxFamily.AC_VOLTAGE) + active = box_representation_decision("ac", VariableBoxFamily.DISPATCHABLE_P) + reactive = box_representation_decision("ac", VariableBoxFamily.DISPATCHABLE_Q) + + assert voltage.representation == "leaf" + assert voltage.authority == "existing_production" + assert active.representation == reactive.representation == "explicit" + assert active.authority == reactive.authority == "ac_explicit_policy" + + +def test_component_boxes_are_explicit_pending_focused_convex_gates(): + expected = { + VariableBoxFamily.STORAGE_REAL_POWER, + VariableBoxFamily.STORAGE_SOC, + VariableBoxFamily.NONDISPATCHABLE_REAL_POWER, + VariableBoxFamily.HVDC_INPUT_POWER, + VariableBoxFamily.LOAD_SHED_FRACTION, + } + assert set(pending_component_box_families()) == expected + + expected_pairs = { + *(("lossy_dc", family) for family in expected), + *( + ("singlenode_dc", family) + for family in expected + if family is not VariableBoxFamily.HVDC_INPUT_POWER + ), + } + assert set(pending_component_box_pairs()) == expected_pairs + for formulation, family in expected_pairs: + decision = box_representation_decision(formulation, family) + assert decision.representation == "explicit" + assert decision.authority == "pending_component_gate" + assert decision.requires_focused_qualification + + +def test_component_box_gates_never_authorize_ac(): + for family in ( + VariableBoxFamily.STORAGE_SOC, + VariableBoxFamily.NONDISPATCHABLE_REAL_POWER, + VariableBoxFamily.HVDC_INPUT_POWER, + VariableBoxFamily.LOAD_SHED_FRACTION, + ): + decision = box_representation_decision("ac", family) + assert decision.representation == "explicit" + assert decision.authority == "ac_explicit_policy" + assert not decision.requires_focused_qualification + + +@pytest.mark.parametrize( + ("formulation", "family"), + [ + ("singlenode_dc", VariableBoxFamily.DC_BRANCH_FLOW), + ("singlenode_dc", VariableBoxFamily.HVDC_INPUT_POWER), + ("ac", VariableBoxFamily.STORAGE_REAL_POWER), + ], +) +def test_inapplicable_box_formulation_pair_is_rejected(formulation, family): + with pytest.raises(ValueError, match="does not apply"): + box_representation_decision(formulation, family) diff --git a/tests/test_m14b_vectorized_component_contract.py b/tests/test_m14b_vectorized_component_contract.py new file mode 100644 index 0000000..fb1fd5a --- /dev/null +++ b/tests/test_m14b_vectorized_component_contract.py @@ -0,0 +1,342 @@ +"""Focused tests for one-call vectorized component assembly.""" + +from dataclasses import dataclass, replace +from typing import Mapping, Sequence + +import cvxpy as cp +import numpy as np +import pytest + +from cvxopf._component_adapter import ( + ComponentAdapter, + DCNetworkState, + FormulationAdapter, + FormulationCapability, + HorizonContribution, + InjectionContribution, + PreparationContext, + VariableSpec, + VectorizedContext, + VectorizedModelContribution, +) +from cvxopf._component_assembly import ( + ComponentRequest, + assemble_component_vectorized, + prepare_components, +) +from cvxopf._temporal_assembly import HorizonVariableSpec + + +@dataclass(frozen=True) +class _Unit: + bus: int + + +def _prepare(units, inputs, context): + incidence = np.zeros((context.nb, len(units))) + for column, unit in enumerate(units): + incidence[context.ext_to_int[unit.bus], column] = 1.0 + return {"incidence": incidence} + + +def _metadata(prepared, formulation): + return {} + + +def _step_specs(units, prepared, context): + return (VariableSpec("p", (len(units),)),) + + +def _step_injection(units, prepared, variables, context): + return InjectionContribution(cp.Constant(np.zeros(2)), None) + + +def _step_constraints(units, prepared, variables, context): + return (variables["p"] >= 0,) + + +def _step_horizon(units, prepared, variables, context): + return HorizonContribution() + + +_CALLS = {"specs": 0, "assembly": 0} + + +def _vector_specs( + units: Sequence[_Unit], + prepared: Mapping[str, object], + context: VectorizedContext, +) -> tuple[HorizonVariableSpec, ...]: + _CALLS["specs"] += 1 + return (HorizonVariableSpec("p", (len(units),)),) + + +def _vector_assembly( + units: Sequence[_Unit], + prepared: Mapping[str, object], + variables: Mapping[str, cp.Variable], + context: VectorizedContext, +) -> VectorizedModelContribution: + _CALLS["assembly"] += 1 + incidence = prepared["incidence"] + assert isinstance(incidence, np.ndarray) + scale = cp.Parameter(nonneg=True, name="test_vector_inv_base") + power = variables["p"] + return VectorizedModelContribution( + injection=InjectionContribution(scale * (incidence @ power), None, scale), + operating_constraints=(power >= 0, power <= 5), + stage_cost_rate=cp.sum(power, axis=0), + expressions={"test_power": power}, + horizon=HorizonContribution( + constraints=(cp.sum(power[:, -1]) <= 8,), + terminal_cost=cp.sum(power[:, -1]), + expressions={"test_terminal_power": cp.sum(power[:, -1])}, + ), + ) + + +def _active(*, vectorized: bool = True) -> FormulationAdapter[_Unit]: + return FormulationAdapter( + capability=FormulationCapability.ACTIVE, + variable_specs=_step_specs, + injections=_step_injection, + operating_constraints=_step_constraints, + horizon=_step_horizon, + vectorized_variable_specs=_vector_specs if vectorized else None, + vectorized_assembly=_vector_assembly if vectorized else None, + ) + + +def _adapter( + binding: FormulationAdapter[_Unit] | None = None, +) -> ComponentAdapter[_Unit, None]: + null = FormulationAdapter[_Unit](capability=FormulationCapability.NULL) + return ComponentAdapter( + name="test_vectorized", + prepare=_prepare, + metadata=_metadata, + formulations={ + "ac": null, + "lossy_dc": _active() if binding is None else binding, + "singlenode_dc": null, + }, + cost_expression_name="test_cost", + ) + + +def _prepared( + binding: FormulationAdapter[_Unit] | None = None, + *, + horizon_steps: int = 4, +): + units = (_Unit(1), _Unit(2)) + context = PreparationContext( + base_mva=100.0, + nb=2, + ext_to_int={1: 0, 2: 1}, + ext_bus_ids=frozenset({1, 2}), + horizon_steps=horizon_steps, + delta=0.5, + is_multistep=True, + ) + return prepare_components( + (ComponentRequest(_adapter(binding), units),), + "lossy_dc", + context, + ) + + +def _context(*, horizon_steps: int = 4) -> VectorizedContext: + return VectorizedContext( + "lossy_dc", + horizon_steps=horizon_steps, + delta=0.5, + base_mva=100.0, + ext_to_int={1: 0, 2: 1}, + network_state=DCNetworkState(), + ) + + +def test_vectorized_component_is_built_once_with_builder_owned_variable(): + _CALLS.update(specs=0, assembly=0) + + contributions = assemble_component_vectorized(_prepared(), _context()) + contribution = contributions["test_vectorized"] + variable = contribution.variables["p"] + + assert _CALLS == {"specs": 1, "assembly": 1} + assert variable.shape == (2, 4) + assert contribution.model.injection.p_pu.shape == (2, 4) + assert contribution.model.injection.inv_base_mva.value == pytest.approx(0.01) + assert contribution.model.stage_cost_rate.shape == (4,) + assert contribution.cost_expression_name == "test_cost" + assert contribution.model.expressions["test_power"] is variable + assert all( + constraint.is_dcp() + for constraint in ( + *contribution.model.operating_constraints, + *contribution.model.horizon.constraints, + ) + ) + with pytest.raises(TypeError): + contribution.variables["other"] = cp.Variable(1) + + +def test_vectorized_component_multistep_t1_keeps_time_axis_and_one_call(): + _CALLS.update(specs=0, assembly=0) + + contributions = assemble_component_vectorized( + _prepared(horizon_steps=1), + _context(horizon_steps=1), + ) + contribution = contributions["test_vectorized"] + + assert _CALLS == {"specs": 1, "assembly": 1} + assert contribution.variables["p"].shape == (2, 1) + assert contribution.model.injection.p_pu.shape == (2, 1) + assert contribution.model.stage_cost_rate.shape == (1,) + + +def test_active_stepwise_binding_may_exist_before_vectorized_migration(): + with pytest.raises(ValueError, match="no vectorized horizon binding"): + assemble_component_vectorized(_prepared(_active(vectorized=False)), _context()) + + +def test_vectorized_hooks_must_be_registered_as_a_pair(): + with pytest.raises(ValueError, match="must be defined together"): + replace(_active(), vectorized_assembly=None) + + +def test_null_binding_cannot_register_vectorized_hooks(): + with pytest.raises(ValueError, match="cannot define hooks"): + FormulationAdapter( + capability=FormulationCapability.NULL, + vectorized_variable_specs=_vector_specs, + vectorized_assembly=_vector_assembly, + ) + + +def test_vectorized_assembly_rejects_injection_shape_drift(): + def bad_assembly(units, prepared, variables, context): + return VectorizedModelContribution( + injection=InjectionContribution(cp.Constant(np.zeros((2, 3))), None) + ) + + binding = replace(_active(), vectorized_assembly=bad_assembly) + with pytest.raises(ValueError, match=r"must have shape \(2, 4\)"): + assemble_component_vectorized(_prepared(binding), _context()) + + +def test_vectorized_assembly_rejects_scalar_stage_cost_rate(): + def bad_assembly(units, prepared, variables, context): + return VectorizedModelContribution( + injection=InjectionContribution(cp.Constant(np.zeros((2, 4))), None), + stage_cost_rate=cp.sum(variables["p"]), + ) + + binding = replace(_active(), vectorized_assembly=bad_assembly) + with pytest.raises(ValueError, match="stage cost rate must have shape"): + assemble_component_vectorized(_prepared(binding), _context()) + + +def test_vectorized_assembly_rejects_concave_stage_cost_rate(): + def bad_assembly(units, prepared, variables, context): + return VectorizedModelContribution( + injection=InjectionContribution(cp.Constant(np.zeros((2, 4))), None), + stage_cost_rate=-cp.sum(cp.square(variables["p"]), axis=0), + ) + + binding = replace(_active(), vectorized_assembly=bad_assembly) + with pytest.raises(ValueError, match="stage cost rate must be convex"): + assemble_component_vectorized(_prepared(binding), _context()) + + +def test_vectorized_assembly_rejects_concave_terminal_cost(): + def bad_assembly(units, prepared, variables, context): + return VectorizedModelContribution( + injection=InjectionContribution(cp.Constant(np.zeros((2, 4))), None), + horizon=HorizonContribution( + terminal_cost=-cp.sum(cp.square(variables["p"][:, -1])) + ), + ) + + binding = replace(_active(), vectorized_assembly=bad_assembly) + with pytest.raises(ValueError, match="terminal cost must be scalar convex"): + assemble_component_vectorized(_prepared(binding), _context()) + + +def test_vectorized_assembly_enforces_device_dcp_boundary(): + def bad_assembly(units, prepared, variables, context): + power = variables["p"] + return VectorizedModelContribution( + injection=InjectionContribution(cp.Constant(np.zeros((2, 4))), None), + operating_constraints=(cp.square(power) == 1,), + ) + + binding = replace(_active(), vectorized_assembly=bad_assembly) + with pytest.raises(ValueError, match="constraints must be DCP"): + assemble_component_vectorized(_prepared(binding), _context()) + + +def test_vectorized_assembly_requires_affine_nodal_injections(): + def bad_assembly(units, prepared, variables, context): + power = variables["p"] + return VectorizedModelContribution( + injection=InjectionContribution(cp.square(power), None), + ) + + binding = replace(_active(), vectorized_assembly=bad_assembly) + with pytest.raises(ValueError, match="injection p_pu must be affine"): + assemble_component_vectorized(_prepared(binding), _context()) + + +def test_vectorized_step_expression_requires_final_time_axis(): + def bad_assembly(units, prepared, variables, context): + return VectorizedModelContribution( + injection=InjectionContribution(cp.Constant(np.zeros((2, 4))), None), + expressions={"collapsed": cp.sum(variables["p"])}, + ) + + binding = replace(_active(), vectorized_assembly=bad_assembly) + with pytest.raises(ValueError, match="must have final axis 4"): + assemble_component_vectorized(_prepared(binding), _context()) + + +@pytest.mark.parametrize( + ("field", "value", "message"), + [ + ("horizon_steps", 3, "horizon_steps"), + ("delta", 1.0, "delta"), + ("base_mva", 50.0, "base_mva"), + ("ext_to_int", {1: 1, 2: 0}, "ext_to_int"), + ], +) +def test_vectorized_context_must_match_preparation(field, value, message): + context = replace(_context(), **{field: value}) + + with pytest.raises(ValueError, match=message): + assemble_component_vectorized(_prepared(), context) + + +def test_vectorized_context_requires_formulation_network_state_pairing(): + with pytest.raises(ValueError, match="requires ACNetworkState"): + VectorizedContext( + "ac", + horizon_steps=2, + delta=1.0, + base_mva=100.0, + ext_to_int={1: 0}, + network_state=DCNetworkState(), + ) + + +def test_duplicate_vectorized_variable_names_are_rejected(): + def duplicate_specs(units, prepared, context): + return ( + HorizonVariableSpec("p", (2,)), + HorizonVariableSpec("p", (2,)), + ) + + binding = replace(_active(), vectorized_variable_specs=duplicate_specs) + with pytest.raises(ValueError, match="duplicate vectorized variables"): + assemble_component_vectorized(_prepared(binding), _context()) From 3ad3f386a9bf4fb21eeb9f55a856f2a5296f88dd Mon Sep 17 00:00:00 2001 From: Bennet Meyers Date: Thu, 27 Aug 2026 17:08:46 -0700 Subject: [PATCH 22/28] feat(m14b): aggregate and publish vectorized horizons Integrate component costs and contributions once per horizon, publish time-last variables and expressions without rebuilding per-step objects, and bind convex vectorized solves to explicit SCIPY canonicalization provenance. --- .../m14_time_vectorization/M14B_PROTOCOL.md | 5 +- plans/milestone-14-time-vectorization.md | 3 +- src/cvxopf/_component_assembly.py | 157 ++++++++++++++++++ src/cvxopf/problem.py | 29 +++- ...test_m14b_vectorized_component_contract.py | 151 +++++++++++++++++ 5 files changed, 338 insertions(+), 7 deletions(-) diff --git a/experiments/m14_time_vectorization/M14B_PROTOCOL.md b/experiments/m14_time_vectorization/M14B_PROTOCOL.md index 127a9f9..977d062 100644 --- a/experiments/m14_time_vectorization/M14B_PROTOCOL.md +++ b/experiments/m14_time_vectorization/M14B_PROTOCOL.md @@ -38,8 +38,9 @@ Lower and upper box faces declare temporal class independently; mixed boxes retain a zero-stride static face while moving only the dynamic face from time-first input to time-last model layout. -The vectorized path uses SCIPY canonicalization. The stepwise path continues to -use CPP. Backend selection is explicit provenance, not an automatic heuristic. +Convex vectorized paths use SCIPY canonicalization. Convex stepwise paths +continue to use CPP, while AC remains on its separately gated DNLP/IPOPT path. +Backend selection is explicit build provenance, not an automatic heuristic. ## Component-specific box qualification diff --git a/plans/milestone-14-time-vectorization.md b/plans/milestone-14-time-vectorization.md index 22b4a14..df2d940 100644 --- a/plans/milestone-14-time-vectorization.md +++ b/plans/milestone-14-time-vectorization.md @@ -342,7 +342,8 @@ Introduce an internal horizon-level assembly path with: where they are the natural representation; - vectorized integration of stage costs and reported component costs; - stable device axes and explicit time axes; -- explicit SCIPY canonicalization for the vectorized solve path; and +- explicit SCIPY canonicalization for convex vectorized solve paths, while AC + remains on its separately gated DNLP/IPOPT path; and - a deliberate compatibility adapter for the existing public `OPFBuild.variables`, expressions, and extraction contracts. diff --git a/src/cvxopf/_component_assembly.py b/src/cvxopf/_component_assembly.py index b3a94a5..23db2c7 100644 --- a/src/cvxopf/_component_assembly.py +++ b/src/cvxopf/_component_assembly.py @@ -604,6 +604,71 @@ def ordered_sum(values: Sequence[cp.Expression]) -> cp.Expression | None: ) +def _ordered_expression_sum( + values: Sequence[cp.Expression], +) -> cp.Expression | None: + """Return a deterministic expression sum without a scalar-zero seed.""" + if not values: + return None + return cast(cp.Expression, sum(values[1:], start=values[0])) + + +def aggregate_vectorized_contributions( + contributions: Mapping[str, VectorizedComponentContribution], +) -> VectorizedComponentContribution: + """Compose complete component horizons without iterating over time.""" + variables: dict[str, cp.Variable] = {} + operating_constraints: list[cp.Constraint] = [] + network_constraints: list[cp.Constraint] = [] + p_injections: list[cp.Expression] = [] + q_injections: list[cp.Expression] = [] + stage_cost_rates: list[cp.Expression] = [] + expressions: dict[str, cp.Expression] = {} + horizon_contributions: dict[str, HorizonContribution] = {} + + for component_name, contribution in contributions.items(): + duplicate_variables = set(variables).intersection(contribution.variables) + if duplicate_variables: + raise ValueError( + f"component {component_name!r} published duplicate vectorized " + f"variables: {sorted(duplicate_variables)}" + ) + variables.update(contribution.variables) + model = contribution.model + if model.injection.p_pu is not None: + p_injections.append(model.injection.p_pu) + if model.injection.q_pu is not None: + q_injections.append(model.injection.q_pu) + operating_constraints.extend(model.operating_constraints) + network_constraints.extend(model.network_constraints) + if model.stage_cost_rate is not None: + stage_cost_rates.append(model.stage_cost_rate) + duplicate_expressions = set(expressions).intersection(model.expressions) + if duplicate_expressions: + raise ValueError( + f"component {component_name!r} published duplicate vectorized " + f"expressions: {sorted(duplicate_expressions)}" + ) + expressions.update(model.expressions) + horizon_contributions[component_name] = model.horizon + + horizon = aggregate_horizon_contributions(horizon_contributions) + return VectorizedComponentContribution( + variables=variables, + model=VectorizedModelContribution( + injection=InjectionContribution( + _ordered_expression_sum(p_injections), + _ordered_expression_sum(q_injections), + ), + operating_constraints=tuple(operating_constraints), + network_constraints=tuple(network_constraints), + stage_cost_rate=_ordered_expression_sum(stage_cost_rates), + expressions=expressions, + horizon=horizon, + ), + ) + + def _validate_expression_names( component_name: str, expressions: Mapping[str, cp.Expression], @@ -718,6 +783,49 @@ def integrate_component_stage_costs( return MappingProxyType(costs) +def integrate_vectorized_stage_cost_rate( + stage_cost_rate: cp.Expression, + delta: float, +) -> cp.Expression: + """Integrate one convex time-last rate vector without a Python time loop.""" + _validate_positive_real("delta", delta) + if not isinstance(stage_cost_rate, cp.Expression): + raise ValueError("vectorized stage cost rate must be a cp.Expression") + if stage_cost_rate.ndim != 1 or stage_cost_rate.shape[0] <= 0: + raise ValueError( + "vectorized stage cost rate must be a nonempty one-dimensional " + f"expression, got {stage_cost_rate.shape}" + ) + if not stage_cost_rate.is_convex(): + raise ValueError("vectorized stage cost rate must be convex") + return cp.multiply(delta, cp.sum(stage_cost_rate)) + + +def integrate_vectorized_component_stage_costs( + contributions: Mapping[str, VectorizedComponentContribution], + delta: float, +) -> Mapping[str, cp.Expression]: + """Integrate and name every component rate once over the horizon.""" + costs: dict[str, cp.Expression] = {} + for component_name, contribution in contributions.items(): + rate = contribution.model.stage_cost_rate + if rate is None: + if contribution.cost_expression_name is not None: + raise ValueError( + f"component {component_name!r} names a cost without " + "providing a stage cost rate" + ) + continue + expression_name = contribution.cost_expression_name or f"{component_name}_cost" + if expression_name in costs: + raise ValueError( + f"component {component_name!r} requested duplicate integrated " + f"cost expression {expression_name!r}" + ) + costs[expression_name] = integrate_vectorized_stage_cost_rate(rate, delta) + return MappingProxyType(costs) + + def _validate_publication_step_count( step_count: int, *, @@ -797,6 +905,24 @@ def publish_component_variables( return published +def publish_vectorized_component_variables( + contribution: VectorizedComponentContribution, + formulation_variables: Mapping[str, cp.Variable] | None = None, +) -> dict[str, cp.Variable]: + """Publish full-horizon variables without recreating per-step objects.""" + published = {} if formulation_variables is None else dict(formulation_variables) + if any(not isinstance(variable, cp.Variable) for variable in published.values()): + raise ValueError("vectorized formulation variables must be cp.Variable objects") + for variable_name, variable in contribution.variables.items(): + if variable_name in published: + raise ValueError( + f"component variable {variable_name!r} collides with an " + "already published vectorized variable" + ) + published[variable_name] = variable + return published + + def publish_component_metadata( prepared: PreparedComponents, formulation_metadata: Mapping[str, object] | None = None, @@ -866,3 +992,34 @@ def publish_component_expressions( ) published.update(horizon_contribution.expressions) return published + + +def publish_vectorized_component_expressions( + contribution: VectorizedComponentContribution, + compatibility_expressions: Mapping[str, cp.Expression], +) -> dict[str, cp.Expression]: + """Publish time-last and horizon expressions without per-step lists.""" + published = dict(compatibility_expressions) + if any( + not isinstance(expression, cp.Expression) for expression in published.values() + ): + raise ValueError( + "vectorized compatibility expressions must be cp.Expression objects" + ) + step_collisions = set(published).intersection(contribution.model.expressions) + if step_collisions: + raise ValueError( + "vectorized component expressions collide with formulation " + f"compatibility expressions: {sorted(step_collisions)}" + ) + published.update(contribution.model.expressions) + horizon_collisions = set(published).intersection( + contribution.model.horizon.expressions + ) + if horizon_collisions: + raise ValueError( + "vectorized horizon expressions collide with published " + f"expressions: {sorted(horizon_collisions)}" + ) + published.update(contribution.model.horizon.expressions) + return published diff --git a/src/cvxopf/problem.py b/src/cvxopf/problem.py index 1d4abb4..02b09f2 100644 --- a/src/cvxopf/problem.py +++ b/src/cvxopf/problem.py @@ -46,6 +46,7 @@ TemporalAssembly = Literal["stepwise", "vectorized"] +CanonicalizationBackend = Literal["CPP", "SCIPY", "DNLP_IPOPT"] # --------------------------------------------------------------------------- @@ -142,17 +143,21 @@ class OPFBuild: AC branch-terminal flow variables are retained in ``expressions`` rather than this mapping. - AC multi-step: each value is a list of length T. + AC stepwise multi-step: each value is a list of length T. + Vectorized multi-step: each value is one cp.Variable whose final axis + is time. ``temporal_assembly`` distinguishes the two representations. DC single-step keys: p_flows, Pg - DC multi-step: each value is a list of length T. + DC stepwise multi-step: each value is a list of length T. + Vectorized multi-step uses one time-last cp.Variable. Singlenode DC single-step keys: Pg - Singlenode DC multi-step: each value is a list of length T. + Singlenode DC stepwise multi-step: each value is a list of length T. + Vectorized multi-step uses one time-last cp.Variable. When storage is present: b (real power, MW), b_q (reactive power, MVAr, AC only), @@ -204,7 +209,8 @@ class OPFBuild: expressions : dict Named modeled CVXPY expressions used for solved-value reporting. Per-step reporting expressions are stored as one expression for a - single-step build and lists of length T for a multistep build. + single-step build, lists of length T for stepwise multistep, and one + time-last expression for vectorized multistep. AC branch-terminal real and reactive powers are retained in per unit as ``branch_p_from_pu``, ``branch_q_from_pu``, ``branch_p_to_pu``, and ``branch_q_to_pu``. Each value has shape @@ -239,6 +245,15 @@ class OPFBuild: expressions: dict[str, Any] = field(default_factory=dict) temporal_assembly: TemporalAssembly = "stepwise" + @property + def canonicalization_backend(self) -> CanonicalizationBackend: + """Return the backend required by this formulation/assembly pair.""" + if not self.is_convex: + return "DNLP_IPOPT" + if self.temporal_assembly == "vectorized": + return "SCIPY" + return "CPP" + def solve(self, **kwargs: Any) -> None: """ Solve the OPF problem with appropriate solver defaults. @@ -265,6 +280,12 @@ def solve(self, **kwargs: Any) -> None: if self.is_convex: kwargs.setdefault("solver", cp.CLARABEL) kwargs.setdefault("nlp", False) + if self.canonicalization_backend == "SCIPY": + backend = kwargs.setdefault("canon_backend", cp.SCIPY_CANON_BACKEND) + if backend != cp.SCIPY_CANON_BACKEND: + raise ValueError( + "vectorized convex builds require SCIPY canonicalization" + ) else: kwargs.setdefault("solver", cp.IPOPT) kwargs.setdefault("nlp", True) diff --git a/tests/test_m14b_vectorized_component_contract.py b/tests/test_m14b_vectorized_component_contract.py index fb1fd5a..b068993 100644 --- a/tests/test_m14b_vectorized_component_contract.py +++ b/tests/test_m14b_vectorized_component_contract.py @@ -2,6 +2,7 @@ from dataclasses import dataclass, replace from typing import Mapping, Sequence +from unittest.mock import Mock import cvxpy as cp import numpy as np @@ -21,10 +22,16 @@ ) from cvxopf._component_assembly import ( ComponentRequest, + aggregate_vectorized_contributions, assemble_component_vectorized, + integrate_vectorized_component_stage_costs, + integrate_vectorized_stage_cost_rate, prepare_components, + publish_vectorized_component_expressions, + publish_vectorized_component_variables, ) from cvxopf._temporal_assembly import HorizonVariableSpec +from cvxopf.problem import OPFBuild @dataclass(frozen=True) @@ -197,6 +204,150 @@ def test_vectorized_component_multistep_t1_keeps_time_axis_and_one_call(): assert contribution.model.stage_cost_rate.shape == (1,) +def test_vectorized_aggregation_integration_and_publication_remain_horizon_native(): + contributions = assemble_component_vectorized(_prepared(), _context()) + component = contributions["test_vectorized"] + + aggregate = aggregate_vectorized_contributions(contributions) + costs = integrate_vectorized_component_stage_costs(contributions, 0.5) + network_variable = cp.Variable((1, 4), name="network_flow") + network_expression = cp.Constant(np.zeros((1, 4))) + variables = publish_vectorized_component_variables( + aggregate, {"network_flow": network_variable} + ) + expressions = publish_vectorized_component_expressions( + aggregate, {"network_loss": network_expression} + ) + + assert aggregate.variables["p"] is component.variables["p"] + assert aggregate.model.injection.p_pu is component.model.injection.p_pu + assert aggregate.model.stage_cost_rate is component.model.stage_cost_rate + assert variables == { + "network_flow": network_variable, + "p": component.variables["p"], + } + assert all(isinstance(variable, cp.Variable) for variable in variables.values()) + assert expressions["network_loss"] is network_expression + assert expressions["test_power"] is component.model.expressions["test_power"] + assert ( + expressions["test_terminal_power"] + is component.model.horizon.expressions["test_terminal_power"] + ) + assert set(costs) == {"test_cost"} + component.variables["p"].value = np.ones((2, 4)) + assert costs["test_cost"].value == pytest.approx(4.0) + + +def test_vectorized_stage_cost_integration_requires_convex_rate_vector(): + with pytest.raises(ValueError, match="one-dimensional"): + integrate_vectorized_stage_cost_rate(cp.Constant(1.0), 1.0) + variable = cp.Variable(3) + with pytest.raises(ValueError, match="must be convex"): + integrate_vectorized_stage_cost_rate(-cp.square(variable), 1.0) + + +def test_vectorized_aggregation_rejects_flat_namespace_collisions(): + contribution = assemble_component_vectorized(_prepared(), _context())[ + "test_vectorized" + ] + other_variable = cp.Variable((2, 4), name="other") + other = replace( + contribution, + variables={"other": other_variable}, + model=replace( + contribution.model, + expressions={"test_power": other_variable}, + ), + ) + + with pytest.raises(ValueError, match="duplicate vectorized variables"): + aggregate_vectorized_contributions( + {"first": contribution, "second": contribution} + ) + with pytest.raises(ValueError, match="duplicate vectorized expressions"): + aggregate_vectorized_contributions({"first": contribution, "second": other}) + + +def test_vectorized_publication_rejects_formulation_collisions(): + aggregate = aggregate_vectorized_contributions( + assemble_component_vectorized(_prepared(), _context()) + ) + + with pytest.raises(ValueError, match="already published"): + publish_vectorized_component_variables(aggregate, {"p": cp.Variable((2, 4))}) + with pytest.raises(ValueError, match="compatibility expressions"): + publish_vectorized_component_expressions( + aggregate, {"test_power": cp.Constant(np.zeros((2, 4)))} + ) + with pytest.raises(ValueError, match="horizon expressions"): + publish_vectorized_component_expressions( + aggregate, + {"test_terminal_power": cp.Constant(0.0)}, + ) + + +def test_vectorized_component_cost_names_remain_globally_unique(): + contribution = assemble_component_vectorized(_prepared(), _context())[ + "test_vectorized" + ] + + with pytest.raises(ValueError, match="duplicate integrated"): + integrate_vectorized_component_stage_costs( + {"first": contribution, "second": contribution}, + 0.5, + ) + + +def test_vectorized_convex_solve_forces_scipy_canonicalization(): + problem = Mock() + build = OPFBuild( + prob=problem, + variables={}, + data={}, + formulation="lossy_dc", + is_convex=True, + temporal_assembly="vectorized", + ) + + build.solve() + + kwargs = problem.solve.call_args.kwargs + assert build.canonicalization_backend == "SCIPY" + assert kwargs["solver"] == cp.CLARABEL + assert kwargs["nlp"] is False + assert kwargs["canon_backend"] == cp.SCIPY_CANON_BACKEND + with pytest.raises(ValueError, match="require SCIPY"): + build.solve(canon_backend=cp.CPP_CANON_BACKEND) + + +def test_build_backend_identity_is_representation_and_formulation_specific(): + problem = Mock() + + assert OPFBuild(problem, {}, {}, "lossy_dc", True).canonicalization_backend == "CPP" + assert ( + OPFBuild( + problem, + {}, + {}, + "singlenode_dc", + True, + temporal_assembly="vectorized", + ).canonicalization_backend + == "SCIPY" + ) + assert ( + OPFBuild( + problem, + {}, + {}, + "ac", + False, + temporal_assembly="vectorized", + ).canonicalization_backend + == "DNLP_IPOPT" + ) + + def test_active_stepwise_binding_may_exist_before_vectorized_migration(): with pytest.raises(ValueError, match="no vectorized horizon binding"): assemble_component_vectorized(_prepared(_active(vectorized=False)), _context()) From 2f4d12a06a7d9e099751866a9f4f38ae0bbcfe52 Mon Sep 17 00:00:00 2001 From: Bennet Meyers Date: Thu, 27 Aug 2026 18:23:47 -0700 Subject: [PATCH 23/28] feat(m14b): add typed vectorized result projection Preserve vectorized variable, expression, boundary-state, and integrated-cost schemas through assembly and project time-last values back to the existing public result contract. Validate required sources and dimensions even without a primal while leaving stepwise extraction unchanged. --- .../m14_time_vectorization/M14B_PROTOCOL.md | 49 ++- plans/milestone-14-time-vectorization.md | 22 +- src/cvxopf/_component_adapter.py | 12 + src/cvxopf/_component_assembly.py | 77 ++++ src/cvxopf/_temporal_assembly.py | 202 ++++++++++ src/cvxopf/problem.py | 8 + src/cvxopf/results.py | 358 ++++++++++-------- tests/test_m14b_temporal_contract.py | 115 +++++- ...test_m14b_vectorized_component_contract.py | 21 + .../test_m14b_vectorized_result_projection.py | 350 +++++++++++++++++ 10 files changed, 1041 insertions(+), 173 deletions(-) create mode 100644 tests/test_m14b_vectorized_result_projection.py diff --git a/experiments/m14_time_vectorization/M14B_PROTOCOL.md b/experiments/m14_time_vectorization/M14B_PROTOCOL.md index 977d062..346b666 100644 --- a/experiments/m14_time_vectorization/M14B_PROTOCOL.md +++ b/experiments/m14_time_vectorization/M14B_PROTOCOL.md @@ -3,9 +3,10 @@ ## Status and authority M14b is open. It is authorized by the immutable M14a legacy baseline and the -M14a.1 leaf-bound qualification record. M14b introduces the internal -time-last horizon assembly contract while keeping the public stepwise/CPP path -available and unchanged by default. +M14a.1 leaf-bound qualification record. The typed horizon, one-call assembly, +aggregation/publication, and compatibility-result projection slices are now +implemented; the focused component-box gates are next. M14b keeps the public +stepwise/CPP path available and unchanged by default. The frozen representation decisions are: @@ -42,6 +43,31 @@ Convex vectorized paths use SCIPY canonicalization. Convex stepwise paths continue to use CPP, while AC remains on its separately gated DNLP/IPOPT path. Backend selection is explicit build provenance, not an automatic heuristic. +## Public result compatibility + +Every vectorized result source carries an immutable typed projection in its +`OPFBuild`. The projection declares the source's internal native shape, public +native shape, and whether it is interval-valued, boundary-valued, or a +once-per-horizon quantity. Extraction never infers a temporal axis from a +field name or an observed shape. + +Interval values move the final axis to the first public axis exactly once. +Storage SoC explicitly projects the `(n_storage, T + 1)` boundary state to the +existing `(T, n_storage)` post-step result by omitting the retained initial +boundary. AC column variables may explicitly flatten their native singleton +axis while preserving the time axis; arbitrary reshaping or axis permutation +is rejected. Component model expressions are interval-valued, while terminal +expressions and integrated component costs are horizon-valued. Horizon totals +remain native scalars or arrays. In particular, `T=1` multistep results remain +unsqueezed. + +The projection registry is source-specific because a variable and a reporting +expression may deliberately share a public name. Missing declarations and +required sources, including on an unavailable-primal path, and shape drift are +extraction errors. Publication and extraction retain the one horizon CVXPY +object and do not reconstruct a length-`T` object list. The existing stepwise +extraction path remains unchanged. + ## Component-specific box qualification M14a.1 qualified formulation-owned generator and network boxes only. The @@ -73,13 +99,16 @@ decision. No convex result authorizes AC. ## Delivery order -1. Freeze typed temporal-field and variable-representation schemas. -2. Add vectorized component request/contribution contracts without calling - scalar hooks `T` times. -3. Implement compatibility publication and extraction without recreating a - length-`T` CVXPY object list. -4. Run the focused component-box gates and freeze their local decisions. -5. Hand the completed assembly contract to M14c's vectorized lossy-DC builder. +1. **Complete:** freeze typed temporal-field and variable-representation + schemas. +2. **Complete:** add vectorized component request/contribution contracts + without calling scalar hooks `T` times. +3. **Complete:** implement compatibility publication and typed extraction + without recreating a length-`T` CVXPY object list. +4. **Next:** run the focused component-box gates and freeze their local + decisions. +5. **Pending:** hand the completed assembly contract to M14c's vectorized + lossy-DC builder. Structural tests cover time-last shapes, `T=1`, static broadcasting, interval identity alignment, boundary indexing, DCP validity of every component term, diff --git a/plans/milestone-14-time-vectorization.md b/plans/milestone-14-time-vectorization.md index df2d940..736de79 100644 --- a/plans/milestone-14-time-vectorization.md +++ b/plans/milestone-14-time-vectorization.md @@ -2,9 +2,11 @@ ## Status -**In progress; M14b open.** The frozen legacy Case9 and Case118 scaling -ladders completed, and the formulation-specific leaf-bound gate passed. -Together these records authorize the horizon-assembly work now in progress. +**In progress; M14b core compatibility contract implemented.** The frozen +legacy Case9 and Case118 scaling ladders completed, and the formulation- +specific leaf-bound gate passed. The typed horizon, one-call assembly, +aggregation/publication, and public-result projection slices are implemented; +focused component-box qualification is next. The M14a baseline is bound to: - execution commit `1dd5e36dcae5ad9c8176b1d1202f1055acf95c03`; @@ -395,6 +397,20 @@ materialize thousands of new CVXPY objects merely to recreate the old internal list representation. If an internal/public representation must change, freeze that change through a separately reviewed typed contract before implementation. +The implemented compatibility boundary uses an immutable, source-specific +projection registry on each vectorized `OPFBuild`. Every extracted variable or +expression declares its internal native shape, public native shape, and +interval, boundary, or horizon view. Interval values move time first exactly +once; storage SoC explicitly omits the retained initial boundary when restoring +the existing `(T, n_storage)` result; horizon totals remain native; and `T=1` +stays unsqueezed. Public native shapes may differ only by removing explicitly +declared singleton axes, never by permuting or reinterpreting physical axes. +Component model expressions are interval-valued; terminal expressions and +integrated component costs are horizon-valued. Missing declarations, missing +required sources even without an accepted primal, or dimensional drift fail +extraction. The adapter retains the original horizon CVXPY objects and never +reconstructs a per-step object list. + ### M14c — Vectorized lossy DC Implement the annual-experiment blocker first: diff --git a/src/cvxopf/_component_adapter.py b/src/cvxopf/_component_adapter.py index 95afe56..61835d1 100644 --- a/src/cvxopf/_component_adapter.py +++ b/src/cvxopf/_component_adapter.py @@ -293,9 +293,21 @@ class VectorizedComponentContribution: variables: Mapping[str, cp.Variable] model: VectorizedModelContribution cost_expression_name: str | None = None + variable_specs: Mapping[str, HorizonVariableSpec] = field(default_factory=dict) def __post_init__(self) -> None: object.__setattr__(self, "variables", _readonly(self.variables)) + specs = dict(self.variable_specs) + if set(specs) != set(self.variables): + raise ValueError( + "vectorized variable specifications must exactly match the " + "published variable names" + ) + if any(name != spec.name for name, spec in specs.items()): + raise ValueError( + "vectorized variable specification keys must match their names" + ) + object.__setattr__(self, "variable_specs", _readonly(specs)) class PrepareHook(Protocol[UnitT_contra, InputT_contra]): diff --git a/src/cvxopf/_component_assembly.py b/src/cvxopf/_component_assembly.py index 23db2c7..e10c50c 100644 --- a/src/cvxopf/_component_assembly.py +++ b/src/cvxopf/_component_assembly.py @@ -33,6 +33,11 @@ _validate_positive_real, bind_injection_scale, ) +from cvxopf._temporal_assembly import ( + HorizonVariableSpec, + ResultProjectionRegistry, + ResultProjectionSpec, +) @dataclass(frozen=True) @@ -443,6 +448,7 @@ def assemble_component_vectorized( model=VectorizedModelContribution( injection=InjectionContribution(None, None) ), + variable_specs={}, ) continue if binding.capability is not FormulationCapability.ACTIVE: @@ -496,6 +502,7 @@ def assemble_component_vectorized( if model.stage_cost_rate is None else component.adapter.cost_expression_name ), + variable_specs={spec.name: spec for spec in specs}, ) return MappingProxyType(contributions) @@ -624,6 +631,7 @@ def aggregate_vectorized_contributions( q_injections: list[cp.Expression] = [] stage_cost_rates: list[cp.Expression] = [] expressions: dict[str, cp.Expression] = {} + variable_specs: dict[str, HorizonVariableSpec] = {} horizon_contributions: dict[str, HorizonContribution] = {} for component_name, contribution in contributions.items(): @@ -634,6 +642,13 @@ def aggregate_vectorized_contributions( f"variables: {sorted(duplicate_variables)}" ) variables.update(contribution.variables) + duplicate_specs = set(variable_specs).intersection(contribution.variable_specs) + if duplicate_specs: + raise ValueError( + f"component {component_name!r} published duplicate vectorized " + f"variable specifications: {sorted(duplicate_specs)}" + ) + variable_specs.update(contribution.variable_specs) model = contribution.model if model.injection.p_pu is not None: p_injections.append(model.injection.p_pu) @@ -666,6 +681,68 @@ def aggregate_vectorized_contributions( expressions=expressions, horizon=horizon, ), + variable_specs=variable_specs, + ) + + +def vectorized_component_result_projections( + contribution: VectorizedComponentContribution, + integrated_component_costs: Mapping[str, cp.Expression] | None = None, +) -> ResultProjectionRegistry: + """Return typed public projections for one aggregated component horizon. + + Variable temporal class and public shape come from the retained variable + specifications. Expression temporal class comes from the contribution + channel itself: model expressions are interval-valued and horizon + expressions are published once. No solved value or name convention is + inspected. + """ + if set(contribution.variables) != set(contribution.variable_specs): + raise ValueError( + "vectorized component variables require retained result schemas" + ) + variables = { + name: spec.result_projection() + for name, spec in contribution.variable_specs.items() + } + expressions = { + name: ResultProjectionSpec( + name, + tuple(int(dimension) for dimension in expression.shape[:-1]), + tuple(int(dimension) for dimension in expression.shape[:-1]), + "interval", + ) + for name, expression in contribution.model.expressions.items() + } + horizon_expressions = dict(contribution.model.horizon.expressions) + for name, expression in ( + {} if integrated_component_costs is None else integrated_component_costs + ).items(): + if not isinstance(expression, cp.Expression) or not expression.is_scalar(): + raise ValueError( + f"integrated component cost {name!r} must be a scalar cp.Expression" + ) + if name in horizon_expressions: + raise ValueError( + f"integrated component cost {name!r} collides with a horizon " + "expression projection" + ) + horizon_expressions[name] = expression + for name, expression in horizon_expressions.items(): + if name in expressions: + raise ValueError( + f"duplicate component result expression projection {name!r}" + ) + native_shape = tuple(int(dimension) for dimension in expression.shape) + expressions[name] = ResultProjectionSpec( + name, + native_shape, + native_shape, + "horizon", + ) + return ResultProjectionRegistry( + variables=variables, + expressions=expressions, ) diff --git a/src/cvxopf/_temporal_assembly.py b/src/cvxopf/_temporal_assembly.py index 7571ef5..b38edc5 100644 --- a/src/cvxopf/_temporal_assembly.py +++ b/src/cvxopf/_temporal_assembly.py @@ -17,6 +17,12 @@ Formulation = Literal["ac", "lossy_dc", "singlenode_dc"] TemporalClass = Literal["static", "interval", "boundary"] BoxRepresentation = Literal["explicit", "leaf"] +ResultTemporalView = Literal[ + "interval", + "all_boundaries", + "post_step_boundaries", + "horizon", +] BoxDecisionAuthority = Literal[ "m14a1_qualified", "existing_production", @@ -103,6 +109,159 @@ def to_public(self, values: np.ndarray, horizon_steps: int) -> np.ndarray: return np.moveaxis(array, -1, 0) +@dataclass(frozen=True) +class ResultProjectionSpec: + """Typed projection from one internal value to its public result layout. + + Vectorized builders retain one time-last CVXPY object. This schema makes + the public layout explicit instead of asking result extraction to infer a + temporal axis from a name or a coincidentally matching shape. + """ + + name: str + internal_native_shape: tuple[int, ...] + public_native_shape: tuple[int, ...] + temporal_view: ResultTemporalView + + def __post_init__(self) -> None: + if not self.name: + raise ValueError("result projection name must be nonempty") + _validate_native_shape(self.internal_native_shape, allow_zero=True) + _validate_native_shape(self.public_native_shape, allow_zero=True) + if self.temporal_view not in { + "interval", + "all_boundaries", + "post_step_boundaries", + "horizon", + }: + raise ValueError(f"invalid result temporal view {self.temporal_view!r}") + if int(np.prod(self.internal_native_shape, dtype=int)) != int( + np.prod(self.public_native_shape, dtype=int) + ): + raise ValueError( + "internal and public native result shapes must contain the " + "same number of coordinates" + ) + remaining_public = iter(self.public_native_shape) + expected_public = next(remaining_public, None) + for dimension in self.internal_native_shape: + if dimension == expected_public: + expected_public = next(remaining_public, None) + elif dimension != 1: + break + else: + if expected_public is None: + return + raise ValueError( + "public native result shape must be obtained from the internal " + "native shape only by removing singleton axes" + ) + + def internal_shape(self, horizon_steps: int) -> tuple[int, ...]: + """Return the exact solved-value shape required by this projection.""" + _validate_horizon_steps(horizon_steps) + if self.temporal_view == "horizon": + return self.internal_native_shape + length = horizon_steps + ( + self.temporal_view in {"all_boundaries", "post_step_boundaries"} + ) + return self.internal_native_shape + (length,) + + def public_shape(self, horizon_steps: int) -> tuple[int, ...]: + """Return the exact public result shape produced by this projection.""" + _validate_horizon_steps(horizon_steps) + if self.temporal_view == "horizon": + return self.public_native_shape + length = horizon_steps + (self.temporal_view == "all_boundaries") + return (length,) + self.public_native_shape + + def project(self, values: np.ndarray, horizon_steps: int) -> np.ndarray: + """Validate and project a solved time-last value exactly once.""" + array = np.asarray(values) + expected = self.internal_shape(horizon_steps) + if array.shape != expected: + raise ValueError( + f"result source {self.name!r} must have internal shape " + f"{expected}, got {array.shape}" + ) + if self.temporal_view == "horizon": + return np.reshape(array, self.public_native_shape) + if self.temporal_view == "post_step_boundaries": + array = array[..., 1:] + time_first = np.moveaxis(array, -1, 0) + return np.reshape(time_first, self.public_shape(horizon_steps)) + + +@dataclass(frozen=True) +class ResultProjectionRegistry: + """Immutable source-specific projection registry for one OPF build.""" + + variables: Mapping[str, ResultProjectionSpec] = field(default_factory=dict) + expressions: Mapping[str, ResultProjectionSpec] = field(default_factory=dict) + + def __post_init__(self) -> None: + variables = dict(self.variables) + expressions = dict(self.expressions) + for source_kind, projections in ( + ("variable", variables), + ("expression", expressions), + ): + mismatches = sorted( + name + for name, projection in projections.items() + if projection.name != name + ) + if mismatches: + raise ValueError( + f"{source_kind} result projection keys must match their " + f"declared names: {mismatches}" + ) + object.__setattr__(self, "variables", MappingProxyType(variables)) + object.__setattr__(self, "expressions", MappingProxyType(expressions)) + + def projection_for( + self, + source_kind: Literal["variable", "expression"], + name: str, + ) -> ResultProjectionSpec: + """Return one required projection with a source-specific error.""" + if source_kind not in {"variable", "expression"}: + raise ValueError(f"unknown result projection source {source_kind!r}") + projections = self.variables if source_kind == "variable" else self.expressions + try: + return projections[name] + except KeyError as error: + raise ValueError( + f"vectorized result {source_kind} {name!r} has no declared " + "public projection" + ) from error + + @property + def is_empty(self) -> bool: + """Return whether no source has a public projection.""" + return not self.variables and not self.expressions + + +def merge_result_projection_registries( + *registries: ResultProjectionRegistry, +) -> ResultProjectionRegistry: + """Merge disjoint registries without silently replacing a declaration.""" + variables: dict[str, ResultProjectionSpec] = {} + expressions: dict[str, ResultProjectionSpec] = {} + for registry in registries: + for source_name, source, destination in ( + ("variable", registry.variables, variables), + ("expression", registry.expressions, expressions), + ): + duplicates = set(destination).intersection(source) + if duplicates: + raise ValueError( + f"duplicate {source_name} result projections: {sorted(duplicates)}" + ) + destination.update(source) + return ResultProjectionRegistry(variables=variables, expressions=expressions) + + @dataclass(frozen=True) class HorizonVariableSpec: """Declarative schema for one interval or boundary CVXPY variable.""" @@ -111,6 +270,10 @@ class HorizonVariableSpec: native_shape: tuple[int, ...] temporal_class: Literal["interval", "boundary"] = "interval" attributes: Mapping[str, object] = field(default_factory=dict) + public_native_shape: tuple[int, ...] | None = None + result_view: ( + Literal["interval", "all_boundaries", "post_step_boundaries"] | None + ) = None def __post_init__(self) -> None: if not self.name: @@ -118,7 +281,35 @@ def __post_init__(self) -> None: _validate_native_shape(self.native_shape, allow_zero=False) if self.temporal_class not in {"interval", "boundary"}: raise ValueError("horizon variables must be interval or boundary") + public_native_shape = ( + self.native_shape + if self.public_native_shape is None + else self.public_native_shape + ) + _validate_native_shape(public_native_shape, allow_zero=False) + view = self.result_view + if view is None: + if self.temporal_class == "boundary": + raise ValueError( + "boundary variables require an explicit public result view" + ) + view = "interval" + if self.temporal_class == "interval" and view != "interval": + raise ValueError("interval variables require an interval result view") + if self.temporal_class == "boundary" and view not in { + "all_boundaries", + "post_step_boundaries", + }: + raise ValueError("boundary variables require a boundary result view") object.__setattr__(self, "attributes", MappingProxyType(dict(self.attributes))) + object.__setattr__(self, "public_native_shape", public_native_shape) + object.__setattr__(self, "result_view", view) + ResultProjectionSpec( + self.name, + self.native_shape, + public_native_shape, + view, + ) def shape(self, horizon_steps: int) -> tuple[int, ...]: """Return the variable's time-last horizon shape.""" @@ -126,6 +317,17 @@ def shape(self, horizon_steps: int) -> tuple[int, ...]: self.name, self.native_shape, self.temporal_class ).internal_shape(horizon_steps) + def result_projection(self) -> ResultProjectionSpec: + """Return the public projection carried by this variable schema.""" + assert self.public_native_shape is not None + assert self.result_view is not None + return ResultProjectionSpec( + self.name, + self.native_shape, + self.public_native_shape, + self.result_view, + ) + def broadcast_static_bound( values: np.ndarray | float, diff --git a/src/cvxopf/problem.py b/src/cvxopf/problem.py index 02b09f2..fecf0fb 100644 --- a/src/cvxopf/problem.py +++ b/src/cvxopf/problem.py @@ -42,6 +42,7 @@ from cvxopf.generator import DispatchableGenerator, _case_with_generators from cvxopf.load import Load from cvxopf._component_adapters import LoadInputs +from cvxopf._temporal_assembly import ResultProjectionRegistry from cvxopf.data import align_device_dataframe, load_timeseries_from_dataframe @@ -235,6 +236,10 @@ class OPFBuild: Temporal graph representation retained as build provenance. Existing single- and multistep builders use ``"stepwise"`` until the M14 horizon-vectorized implementation is selected explicitly. + result_projections : ResultProjectionRegistry + Immutable variable/expression schemas used only by vectorized result + extraction to move time from the final internal axis to the first + public axis. Stepwise extraction retains its existing list contract. """ prob: cp.Problem @@ -244,6 +249,9 @@ class OPFBuild: is_convex: bool expressions: dict[str, Any] = field(default_factory=dict) temporal_assembly: TemporalAssembly = "stepwise" + result_projections: ResultProjectionRegistry = field( + default_factory=ResultProjectionRegistry + ) @property def canonicalization_backend(self) -> CanonicalizationBackend: diff --git a/src/cvxopf/results.py b/src/cvxopf/results.py index 4c85d2d..dbbc005 100644 --- a/src/cvxopf/results.py +++ b/src/cvxopf/results.py @@ -45,8 +45,11 @@ from __future__ import annotations +from typing import Any, Literal + import numpy as np +from cvxopf._temporal_assembly import ResultProjectionSpec from cvxopf.hvdc import _loss_values from cvxopf.nondispatchable import _curtailment_values from cvxopf.problem import OPFBuild @@ -55,22 +58,77 @@ def _solved_expression_value(build: OPFBuild, name: str) -> float: """Return a scalar value from the exact expression used by the model.""" - value = build.expressions[name].value - return float(value) if value is not None else float("nan") + if name not in build.expressions: + if build.temporal_assembly == "vectorized": + raise ValueError(f"missing required vectorized result expression {name!r}") + raise KeyError(name) + value = _solved_expression_values(build, name) + if value is None: + return float("nan") + array = np.asarray(value) + if array.shape != (): + raise ValueError( + f"modeled scalar expression {name!r} produced shape {array.shape}" + ) + return float(array) + + +def _vectorized_projection( + build: OPFBuild, + source_kind: Literal["variable", "expression"], + name: str, +) -> ResultProjectionSpec: + """Return the trusted projection for one vectorized solved source.""" + if "T" not in build.data: + raise ValueError("vectorized result extraction requires horizon metadata T") + return build.result_projections.projection_for(source_kind, name) + + +def _project_vectorized_value( + build: OPFBuild, + source_kind: Literal["variable", "expression"], + name: str, + source_shape: tuple[int, ...], + value: Any, +) -> np.ndarray | None: + """Project one available time-last value under its frozen schema.""" + projection = _vectorized_projection(build, source_kind, name) + horizon_steps = int(build.data["T"]) + expected = projection.internal_shape(horizon_steps) + if source_shape != expected: + raise ValueError( + f"vectorized result {source_kind} {name!r} declares source shape " + f"{source_shape}, but its projection requires {expected}" + ) + return ( + None if value is None else projection.project(np.asarray(value), horizon_steps) + ) -def _solved_expression_values(build: OPFBuild, name: str): +def _solved_expression_values( + build: OPFBuild, name: str +) -> np.ndarray | np.generic | float | None: """Evaluate a named single- or multi-step modeled expression.""" expression = build.expressions.get(name) if expression is None: + if build.temporal_assembly == "vectorized": + raise ValueError(f"missing required vectorized result expression {name!r}") return None if isinstance(expression, list): values = [item.value for item in expression] return None if any(value is None for value in values) else np.array(values) + if build.temporal_assembly == "vectorized": + return _project_vectorized_value( + build, + "expression", + name, + tuple(int(dimension) for dimension in expression.shape), + expression.value, + ) return expression.value -def _scaled_values(value, scale: float): +def _scaled_values(value: Any, scale: float) -> Any: """Scale an available scalar or array while preserving ``None``.""" return None if value is None else value * scale @@ -83,14 +141,22 @@ def _objective_value(build: OPFBuild) -> float: return float(value) -def _initialize_results(build: OPFBuild) -> dict: +def _initialize_results(build: OPFBuild) -> dict[str, Any]: """Initialize the public schema from the built model, before values.""" core_fields = { "ac": ( - "Pg", "Qg", "Vm", "Va_deg", "p_net", "q_net", - "branch_p_from", "branch_q_from", - "branch_p_to", "branch_q_to", - "branch_s_from", "branch_s_to", + "Pg", + "Qg", + "Vm", + "Va_deg", + "p_net", + "q_net", + "branch_p_from", + "branch_q_from", + "branch_p_to", + "branch_q_to", + "branch_s_from", + "branch_s_to", ), "lossy_dc": ("Pg", "p_flows", "p_net"), "singlenode_dc": ("Pg", "p_net"), @@ -149,35 +215,46 @@ def _initialize_results(build: OPFBuild) -> dict: return results -def _variable_values(variable): +def _variable_values(build: OPFBuild, name: str) -> Any: """Return one variable value or stack a multistep variable list.""" + if name not in build.variables: + if build.temporal_assembly == "vectorized": + raise ValueError(f"missing required vectorized result variable {name!r}") + raise KeyError(name) + variable = build.variables[name] if isinstance(variable, list): values = [item.value for item in variable] if any(value is None for value in values): return None return np.array(values) + if build.temporal_assembly == "vectorized": + return _project_vectorized_value( + build, + "variable", + name, + tuple(int(dimension) for dimension in variable.shape), + variable.value, + ) return variable.value -def _add_storage_results(results: dict, build: OPFBuild) -> None: +def _add_storage_results(results: dict[str, Any], build: OPFBuild) -> None: """Add storage-owned variables and modeled cost to a result dictionary.""" if "ns" not in build.data: return - results["b"] = _variable_values(build.variables["b"]) + results["b"] = _variable_values(build, "b") if "b_q" in build.variables: - results["b_q"] = _variable_values(build.variables["b_q"]) - results["soc"] = _variable_values(build.variables["soc"]) + results["b_q"] = _variable_values(build, "b_q") + results["soc"] = _variable_values(build, "soc") results["storage_cost"] = _solved_expression_value(build, "storage_cost") targets = build.data["storage_terminal_soc"] if np.any(np.isfinite(targets)): if results["soc"] is None: results["storage_terminal_deviation"] = None else: - terminal_soc = ( - results["soc"][-1] if "T" in build.data else results["soc"] - ) - results["storage_terminal_deviation"] = ( - _terminal_deviation_values(targets, terminal_soc) + terminal_soc = results["soc"][-1] if "T" in build.data else results["soc"] + results["storage_terminal_deviation"] = _terminal_deviation_values( + targets, terminal_soc ) if "storage_terminal_cost" in build.expressions: results["storage_terminal_cost"] = _solved_expression_value( @@ -185,90 +262,67 @@ def _add_storage_results(results: dict, build: OPFBuild) -> None: ) -def _add_nd_results(results: dict, build: OPFBuild) -> None: +def _add_nd_results(results: dict[str, Any], build: OPFBuild) -> None: """Add ND variables and device-owned curtailment values.""" if "nnd" not in build.data: return - results["p_nd"] = _variable_values(build.variables["p_nd"]) + results["p_nd"] = _variable_values(build, "p_nd") if "q_nd" in build.variables: - results["q_nd"] = _variable_values(build.variables["q_nd"]) - availability_key = ( - "nd_available" if "T" in build.data else "nd_p_available" - ) + results["q_nd"] = _variable_values(build, "q_nd") + availability_key = "nd_available" if "T" in build.data else "nd_p_available" results["curtailment"] = ( None if results["p_nd"] is None - else _curtailment_values( - build.data[availability_key], results["p_nd"] - ) + else _curtailment_values(build.data[availability_key], results["p_nd"]) ) -def _add_hvdc_results(results: dict, build: OPFBuild) -> None: +def _add_hvdc_results(results: dict[str, Any], build: OPFBuild) -> None: """Add HVDC terminal injections and device-owned loss values.""" if "n_hvdc" not in build.data: return - results["p_hvdc_in"] = _variable_values(build.variables["p_hvdc_in"]) - results["p_hvdc_out"] = _variable_values(build.variables["p_hvdc_out"]) + results["p_hvdc_in"] = _variable_values(build, "p_hvdc_in") + results["p_hvdc_out"] = _variable_values(build, "p_hvdc_out") results["hvdc_loss"] = ( None - if ( - results["p_hvdc_in"] is None - or results["p_hvdc_out"] is None - ) - else _loss_values( + if (results["p_hvdc_in"] is None or results["p_hvdc_out"] is None) + else _loss_values( # type: ignore[no-untyped-call] results["p_hvdc_in"], results["p_hvdc_out"] ) ) -def _add_load_results(results: dict, build: OPFBuild) -> None: +def _add_load_results(results: dict[str, Any], build: OPFBuild) -> None: """Add exogenous inputs and conditional served/shedding results.""" if "nload" not in build.data: return results["p_load"] = _solved_expression_values(build, "p_load") results["q_load"] = _solved_expression_values(build, "q_load") if int(build.data["nsheddable"]) == 0: - results["p_load_served"] = _solved_expression_values( - build, "p_load_served" - ) + results["p_load_served"] = _solved_expression_values(build, "p_load_served") if build.formulation == "ac": - results["q_load_served"] = _solved_expression_values( - build, "q_load_served" - ) + results["q_load_served"] = _solved_expression_values(build, "q_load_served") return - results["p_load_served"] = _solved_expression_values( - build, "p_load_served" - ) - results["p_load_shed"] = _solved_expression_values( - build, "p_load_shed" - ) + results["p_load_served"] = _solved_expression_values(build, "p_load_served") + results["p_load_shed"] = _solved_expression_values(build, "p_load_shed") results["load_shed_fraction"] = _solved_expression_values( build, "load_shed_fraction" ) - results["p_load_shed_total"] = _solved_expression_values( - build, "p_load_shed_total" - ) + results["p_load_shed_total"] = _solved_expression_values(build, "p_load_shed_total") if build.formulation == "ac": - results["q_load_served"] = _solved_expression_values( - build, "q_load_served" - ) - results["q_load_shed"] = _solved_expression_values( - build, "q_load_shed" - ) + results["q_load_served"] = _solved_expression_values(build, "q_load_served") + results["q_load_shed"] = _solved_expression_values(build, "q_load_shed") results["energy_not_served_by_load"] = _solved_expression_values( build, "energy_not_served_by_load" ) - results["energy_not_served"] = _solved_expression_values( - build, "energy_not_served" - ) + results["energy_not_served"] = _solved_expression_values(build, "energy_not_served") results["load_shedding_cost"] = _solved_expression_value( build, "load_shedding_cost" ) -def _add_device_results(results: dict, build: OPFBuild) -> None: +def _add_device_results(results: dict[str, Any], build: OPFBuild) -> None: """Add every optional device's reported values.""" _add_storage_results(results, build) _add_nd_results(results, build) @@ -276,7 +330,7 @@ def _add_device_results(results: dict, build: OPFBuild) -> None: _add_load_results(results, build) -def _add_ac_branch_results(results: dict, build: OPFBuild) -> None: +def _add_ac_branch_results(results: dict[str, Any], build: OPFBuild) -> None: """Add signed AC branch-terminal powers and derived magnitudes.""" base_mva = float(build.data["baseMVA"]) signed = { @@ -305,9 +359,7 @@ def _add_ac_branch_results(results: dict, build: OPFBuild) -> None: results["branch_s_from"] = np.hypot( signed["branch_p_from"], signed["branch_q_from"] ) - results["branch_s_to"] = np.hypot( - signed["branch_p_to"], signed["branch_q_to"] - ) + results["branch_s_to"] = np.hypot(signed["branch_p_to"], signed["branch_q_to"]) # --------------------------------------------------------------------------- @@ -315,7 +367,7 @@ def _add_ac_branch_results(results: dict, build: OPFBuild) -> None: # --------------------------------------------------------------------------- -def extract_results(build: OPFBuild) -> dict: +def extract_results(build: OPFBuild) -> dict[str, Any]: """ Extract and scale solver results from a solved OPFBuild. @@ -411,7 +463,9 @@ def extract_results(build: OPFBuild) -> dict: ) -def compare_to_reference(results: dict, reference: dict) -> dict: +def compare_to_reference( + results: dict[str, Any], reference: dict[str, Any] +) -> dict[str, Any]: """ Compute structured differences between cvxopf results and a reference fixture dict (typically from Pypower). @@ -445,18 +499,18 @@ def compare_to_reference(results: dict, reference: dict) -> dict: if f not in results or f not in reference: continue - cv = np.asarray(results[f], dtype=float) + cv = np.asarray(results[f], dtype=float) ref = np.asarray(reference[f], dtype=float) abs_diff = np.abs(cv - ref) - denom = np.where(np.abs(ref) > 1e-8, np.abs(ref), 1.0) + denom = np.where(np.abs(ref) > 1e-8, np.abs(ref), 1.0) rel_diff = abs_diff / denom comparison[f] = dict( - cvxopf = cv, - reference = ref, - abs_diff = abs_diff, - rel_diff = rel_diff, + cvxopf=cv, + reference=ref, + abs_diff=abs_diff, + rel_diff=rel_diff, ) return comparison @@ -467,12 +521,12 @@ def compare_to_reference(results: dict, reference: dict) -> dict: # --------------------------------------------------------------------------- -def _extract_ac_results(build: OPFBuild) -> dict: +def _extract_ac_results(build: OPFBuild) -> dict[str, Any]: """Extract results for AC formulation (single-step or multi-step).""" - var = build.variables - data = build.data + var = build.variables + data = build.data baseMVA = float(data["baseMVA"]) - prob = build.prob + prob = build.prob results = _initialize_results(build) multistep = "T" in data @@ -481,117 +535,107 @@ def _extract_ac_results(build: OPFBuild) -> dict: voltage = var["v"].value angle = var["theta"].value results.update( - status = prob.status, - objective = _objective_value(build), - Pg = _scaled_values(var["Pg"].value, baseMVA), - Qg = _scaled_values(var["Qg"].value, baseMVA), - Vm = None if voltage is None else voltage.flatten(), - Va_deg = ( - None - if angle is None - else np.rad2deg(angle.flatten()) - ), - p_net = _scaled_values( - _solved_expression_values(build, "p_net"), baseMVA - ), - q_net = _scaled_values( - _solved_expression_values(build, "q_net"), baseMVA - ), + status=prob.status, + objective=_objective_value(build), + Pg=_scaled_values(var["Pg"].value, baseMVA), + Qg=_scaled_values(var["Qg"].value, baseMVA), + Vm=None if voltage is None else voltage.flatten(), + Va_deg=(None if angle is None else np.rad2deg(angle.flatten())), + p_net=_scaled_values(_solved_expression_values(build, "p_net"), baseMVA), + q_net=_scaled_values(_solved_expression_values(build, "q_net"), baseMVA), ) - - if voltage is not None and angle is not None: + + if build.temporal_assembly == "vectorized" or ( + voltage is not None and angle is not None + ): _add_ac_branch_results(results, build) _add_device_results(results, build) return results - Pg_values = _variable_values(var["Pg"]) - Qg_values = _variable_values(var["Qg"]) - voltage = _variable_values(var["v"]) - angle = _variable_values(var["theta"]) + Pg_values = _variable_values(build, "Pg") + Qg_values = _variable_values(build, "Qg") + voltage = _variable_values(build, "v") + angle = _variable_values(build, "theta") + public_voltage = ( + voltage + if build.temporal_assembly == "vectorized" or voltage is None + else np.squeeze(voltage, axis=-1) + ) + public_angle = ( + angle + if build.temporal_assembly == "vectorized" or angle is None + else np.squeeze(angle, axis=-1) + ) results.update( - status = prob.status, - objective = _objective_value(build), - Pg = _scaled_values(Pg_values, baseMVA), - Qg = _scaled_values(Qg_values, baseMVA), - Vm = ( - None if voltage is None else np.squeeze(voltage, axis=-1) - ), - Va_deg = ( - None - if angle is None - else np.rad2deg(np.squeeze(angle, axis=-1)) - ), - p_net = _scaled_values( - _solved_expression_values(build, "p_net"), baseMVA - ), - q_net = _scaled_values( - _solved_expression_values(build, "q_net"), baseMVA - ), + status=prob.status, + objective=_objective_value(build), + Pg=_scaled_values(Pg_values, baseMVA), + Qg=_scaled_values(Qg_values, baseMVA), + Vm=public_voltage, + Va_deg=(None if public_angle is None else np.rad2deg(public_angle)), + p_net=_scaled_values(_solved_expression_values(build, "p_net"), baseMVA), + q_net=_scaled_values(_solved_expression_values(build, "q_net"), baseMVA), ) - - if voltage is not None and angle is not None: + + if build.temporal_assembly == "vectorized" or ( + voltage is not None and angle is not None + ): _add_ac_branch_results(results, build) _add_device_results(results, build) return results -def _extract_dc_results(build: OPFBuild) -> dict: +def _extract_dc_results(build: OPFBuild) -> dict[str, Any]: """ Extract results for lossy DC formulation (single-step or multi-step). Pg is stored directly as a per-generator (ng,) variable. Nodal net injection is evaluated from the exact expression used in power balance. """ - var = build.variables - data = build.data + var = build.variables + data = build.data baseMVA = float(data["baseMVA"]) - prob = build.prob + prob = build.prob multistep = "T" in data results = _initialize_results(build) if not multistep: - Pg_val = var["Pg"].value + Pg_val = var["Pg"].value p_flows_val = var["p_flows"].value results.update( - status = prob.status, - objective = _objective_value(build), - Pg = _scaled_values(Pg_val, baseMVA), - p_flows = _scaled_values(p_flows_val, baseMVA), - p_net = _scaled_values( - _solved_expression_values(build, "p_net"), baseMVA - ), + status=prob.status, + objective=_objective_value(build), + Pg=_scaled_values(Pg_val, baseMVA), + p_flows=_scaled_values(p_flows_val, baseMVA), + p_net=_scaled_values(_solved_expression_values(build, "p_net"), baseMVA), ) - + _add_device_results(results, build) return results results.update( - status = prob.status, - objective = _objective_value(build), - Pg = _scaled_values(_variable_values(var["Pg"]), baseMVA), - p_flows = _scaled_values( - _variable_values(var["p_flows"]), baseMVA - ), - p_net = _scaled_values( - _solved_expression_values(build, "p_net"), baseMVA - ), + status=prob.status, + objective=_objective_value(build), + Pg=_scaled_values(_variable_values(build, "Pg"), baseMVA), + p_flows=_scaled_values(_variable_values(build, "p_flows"), baseMVA), + p_net=_scaled_values(_solved_expression_values(build, "p_net"), baseMVA), ) - + _add_device_results(results, build) return results -def _extract_singlenode_dc_results(build: OPFBuild) -> dict: +def _extract_singlenode_dc_results(build: OPFBuild) -> dict[str, Any]: """ Extract results for single-node DC formulation (single-step or multi-step). For single-node DC, Pg is (ng,) in single-step or (T, ng) in multi-step. p_net is a scalar float in single-step or (T,) array in multi-step. """ - var = build.variables - data = build.data + var = build.variables + data = build.data baseMVA = float(data["baseMVA"]) - prob = build.prob + prob = build.prob results = _initialize_results(build) multistep = "T" in data @@ -602,24 +646,20 @@ def _extract_singlenode_dc_results(build: OPFBuild) -> dict: p_net = _solved_expression_values(build, "p_net") results.update( - status = prob.status, - objective = _objective_value(build), - Pg = _scaled_values(Pg_val, baseMVA), - p_net = ( - None if p_net is None else float(p_net * baseMVA) - ), + status=prob.status, + objective=_objective_value(build), + Pg=_scaled_values(Pg_val, baseMVA), + p_net=(None if p_net is None else float(p_net * baseMVA)), ) _add_device_results(results, build) return results results.update( - status = prob.status, - objective = _objective_value(build), - Pg = _scaled_values(_variable_values(var["Pg"]), baseMVA), - p_net = _scaled_values( - _solved_expression_values(build, "p_net"), baseMVA - ), + status=prob.status, + objective=_objective_value(build), + Pg=_scaled_values(_variable_values(build, "Pg"), baseMVA), + p_net=_scaled_values(_solved_expression_values(build, "p_net"), baseMVA), ) _add_device_results(results, build) diff --git a/tests/test_m14b_temporal_contract.py b/tests/test_m14b_temporal_contract.py index de64878..cabcd2e 100644 --- a/tests/test_m14b_temporal_contract.py +++ b/tests/test_m14b_temporal_contract.py @@ -5,10 +5,13 @@ from cvxopf._temporal_assembly import ( HorizonVariableSpec, + ResultProjectionRegistry, + ResultProjectionSpec, TemporalFieldSpec, VariableBoxFamily, box_representation_decision, broadcast_static_bound, + merge_result_projection_registries, pending_component_box_families, pending_component_box_pairs, prepare_box_bounds, @@ -40,7 +43,12 @@ def test_temporal_field_shapes_and_axis_round_trip( def test_scalar_interval_field_and_boundary_variable_lift_one_axis(): interval = TemporalFieldSpec("rate", (), "interval") - boundary = HorizonVariableSpec("soc", (3,), "boundary") + boundary = HorizonVariableSpec( + "soc", + (3,), + "boundary", + result_view="post_step_boundaries", + ) assert interval.internal_shape(7) == (7,) assert boundary.shape(7) == (3, 8) @@ -232,6 +240,111 @@ def test_multistep_t1_preserves_interval_and_boundary_axes(): assert np.array_equal(boundary.to_public(boundary_internal, 1), boundary_public) +def test_interval_result_projection_moves_time_first_and_keeps_t1_unsqueezed(): + projection = ResultProjectionSpec("Pg", (2,), (2,), "interval") + values = np.array([[1.0], [2.0]]) + + public = projection.project(values, 1) + + assert projection.internal_shape(1) == (2, 1) + assert projection.public_shape(1) == (1, 2) + assert public.shape == (1, 2) + np.testing.assert_array_equal(public, [[1.0, 2.0]]) + + +def test_boundary_result_projection_selects_post_step_states_explicitly(): + projection = ResultProjectionSpec("soc", (2,), (2,), "post_step_boundaries") + values = np.array([[10.0, 11.0, 12.0], [20.0, 21.0, 22.0]]) + + public = projection.project(values, 2) + + assert projection.internal_shape(2) == (2, 3) + assert projection.public_shape(2) == (2, 2) + np.testing.assert_array_equal(public, [[11.0, 21.0], [12.0, 22.0]]) + + +def test_result_projection_can_publish_all_boundaries_or_reshape_native_axes(): + boundaries = ResultProjectionSpec("state", (2,), (2,), "all_boundaries") + flattened = ResultProjectionSpec("v", (2, 1), (2,), "interval") + + np.testing.assert_array_equal( + boundaries.project(np.array([[1.0, 2.0], [3.0, 4.0]]), 1), + [[1.0, 3.0], [2.0, 4.0]], + ) + voltage = flattened.project(np.arange(6).reshape(2, 1, 3), 3) + assert voltage.shape == (3, 2) + np.testing.assert_array_equal(voltage, [[0, 3], [1, 4], [2, 5]]) + + +def test_horizon_result_projection_has_no_temporal_axis(): + projection = ResultProjectionSpec("ens", (2, 1), (2,), "horizon") + + public = projection.project(np.array([[3.0], [4.0]]), 8) + + assert public.shape == (2,) + np.testing.assert_array_equal(public, [3.0, 4.0]) + + +def test_result_projection_rejects_shape_and_coordinate_drift(): + with pytest.raises(ValueError, match="same number of coordinates"): + ResultProjectionSpec("bad", (2,), (3,), "interval") + with pytest.raises(ValueError, match="only by removing singleton axes"): + ResultProjectionSpec("reordered", (2, 3), (3, 2), "interval") + with pytest.raises(ValueError, match="only by removing singleton axes"): + ResultProjectionSpec("moved_singleton", (2, 1), (1, 2), "interval") + projection = ResultProjectionSpec("Pg", (2,), (2,), "interval") + with pytest.raises(ValueError, match="internal shape"): + projection.project(np.ones((2, 4)), 3) + + +def test_horizon_variable_retains_its_public_result_projection(): + interval = HorizonVariableSpec("Pg", (3,)) + boundary = HorizonVariableSpec( + "soc", + (2,), + "boundary", + result_view="post_step_boundaries", + ) + voltage = HorizonVariableSpec( + "v", + (4, 1), + public_native_shape=(4,), + ) + + assert interval.result_projection().temporal_view == "interval" + assert boundary.result_projection().temporal_view == "post_step_boundaries" + assert voltage.result_projection().public_native_shape == (4,) + + with pytest.raises(ValueError, match="only by removing singleton axes"): + HorizonVariableSpec("bad", (2, 3), public_native_shape=(3, 2)) + + +def test_boundary_variable_requires_deliberate_public_result_view(): + with pytest.raises(ValueError, match="explicit public result view"): + HorizonVariableSpec("soc", (2,), "boundary") + + +def test_result_projection_registry_is_immutable_source_specific_and_mergeable(): + variable = ResultProjectionSpec("Pg", (2,), (2,), "interval") + expression = ResultProjectionSpec("p_net", (3,), (3,), "interval") + registry = merge_result_projection_registries( + ResultProjectionRegistry(variables={"Pg": variable}), + ResultProjectionRegistry(expressions={"p_net": expression}), + ) + + assert registry.projection_for("variable", "Pg") is variable + assert registry.projection_for("expression", "p_net") is expression + with pytest.raises(TypeError): + registry.variables["other"] = variable + with pytest.raises(ValueError, match="no declared"): + registry.projection_for("variable", "missing") + with pytest.raises(ValueError, match="duplicate variable"): + merge_result_projection_registries( + registry, + ResultProjectionRegistry(variables={"Pg": variable}), + ) + + @pytest.mark.parametrize( ("formulation", "family"), [ diff --git a/tests/test_m14b_vectorized_component_contract.py b/tests/test_m14b_vectorized_component_contract.py index b068993..31de96d 100644 --- a/tests/test_m14b_vectorized_component_contract.py +++ b/tests/test_m14b_vectorized_component_contract.py @@ -29,6 +29,7 @@ prepare_components, publish_vectorized_component_expressions, publish_vectorized_component_variables, + vectorized_component_result_projections, ) from cvxopf._temporal_assembly import HorizonVariableSpec from cvxopf.problem import OPFBuild @@ -177,6 +178,7 @@ def test_vectorized_component_is_built_once_with_builder_owned_variable(): assert contribution.model.injection.inv_base_mva.value == pytest.approx(0.01) assert contribution.model.stage_cost_rate.shape == (4,) assert contribution.cost_expression_name == "test_cost" + assert contribution.variable_specs["p"].shape(4) == (2, 4) assert contribution.model.expressions["test_power"] is variable assert all( constraint.is_dcp() @@ -238,6 +240,24 @@ def test_vectorized_aggregation_integration_and_publication_remain_horizon_nativ assert costs["test_cost"].value == pytest.approx(4.0) +def test_vectorized_component_publication_retains_typed_result_projections(): + contributions = assemble_component_vectorized(_prepared(), _context()) + aggregate = aggregate_vectorized_contributions(contributions) + costs = integrate_vectorized_component_stage_costs(contributions, 0.5) + + projections = vectorized_component_result_projections( + aggregate, + integrated_component_costs=costs, + ) + + assert projections.variables["p"].internal_shape(4) == (2, 4) + assert projections.variables["p"].public_shape(4) == (4, 2) + assert projections.expressions["test_power"].temporal_view == "interval" + assert projections.expressions["test_terminal_power"].temporal_view == "horizon" + assert projections.expressions["test_cost"].temporal_view == "horizon" + assert projections.expressions["test_cost"].public_shape(4) == () + + def test_vectorized_stage_cost_integration_requires_convex_rate_vector(): with pytest.raises(ValueError, match="one-dimensional"): integrate_vectorized_stage_cost_rate(cp.Constant(1.0), 1.0) @@ -254,6 +274,7 @@ def test_vectorized_aggregation_rejects_flat_namespace_collisions(): other = replace( contribution, variables={"other": other_variable}, + variable_specs={"other": HorizonVariableSpec("other", (2,))}, model=replace( contribution.model, expressions={"test_power": other_variable}, diff --git a/tests/test_m14b_vectorized_result_projection.py b/tests/test_m14b_vectorized_result_projection.py new file mode 100644 index 0000000..5304052 --- /dev/null +++ b/tests/test_m14b_vectorized_result_projection.py @@ -0,0 +1,350 @@ +"""Focused result-compatibility gates for M14b time-last horizons.""" + +from types import MappingProxyType + +import cvxpy as cp +import numpy as np +import pytest + +from cvxopf._temporal_assembly import ( + ResultProjectionRegistry, + ResultProjectionSpec, +) +from cvxopf.problem import OPFBuild +from cvxopf.results import _solved_expression_value, extract_results + + +def _interval(name: str, native_shape: tuple[int, ...]) -> ResultProjectionSpec: + return ResultProjectionSpec(name, native_shape, native_shape, "interval") + + +def _horizon(name: str, native_shape: tuple[int, ...]) -> ResultProjectionSpec: + return ResultProjectionSpec(name, native_shape, native_shape, "horizon") + + +def _assign(variable: cp.Variable, values: np.ndarray) -> cp.Variable: + variable.value = np.asarray(values, dtype=float) + return variable + + +def _lossy_vectorized_build( + *, solved_values: bool = True, horizon: int = 3 +) -> OPFBuild: + pg = cp.Variable((2, horizon), name="Pg") + flow = cp.Variable((1, horizon), name="p_flows") + battery = cp.Variable((1, horizon), name="b") + soc = cp.Variable((1, horizon + 1), name="soc") + renewable = cp.Variable((1, horizon), name="p_nd") + hvdc_in = cp.Variable((1, horizon), name="p_hvdc_in") + hvdc_out = cp.Variable((1, horizon), name="p_hvdc_out") + shed_fraction = cp.Variable((1, horizon), name="load_shed_fraction") + + if solved_values: + _assign(pg, np.arange(2 * horizon).reshape(2, horizon) / 100.0) + _assign(flow, np.arange(horizon).reshape(1, horizon) / 100.0) + _assign(battery, np.array([[1.0, -2.0, 3.0]])[:, :horizon]) + _assign(soc, np.array([[10.0, 11.0, 9.0, 12.0]])[:, : horizon + 1]) + _assign(renewable, np.array([[4.0, 5.0, 6.0]])[:, :horizon]) + _assign(hvdc_in, np.array([[-2.0, -3.0, -4.0]])[:, :horizon]) + _assign(hvdc_out, np.array([[1.8, 2.7, 3.6]])[:, :horizon]) + _assign(shed_fraction, np.array([[0.1, 0.0, 0.2]])[:, :horizon]) + + p_load = cp.Constant( + np.array([[10.0, 11.0, 12.0], [20.0, 21.0, 22.0]])[:, :horizon] + ) + q_load = cp.Constant(np.array([[1.0, 1.1, 1.2], [2.0, 2.1, 2.2]])[:, :horizon]) + p_shed = cp.multiply( + shed_fraction, + cp.Constant(np.array([[10.0, 11.0, 12.0]])[:, :horizon]), + ) + p_served = cp.vstack((p_load[0, :] - p_shed[0, :], p_load[1, :])) + p_net = cp.vstack((pg[0, :] - flow[0, :], pg[1, :] + flow[0, :])) + expressions = { + "p_net": p_net, + "storage_cost": cp.sum(cp.abs(battery)), + "p_load": p_load, + "q_load": q_load, + "p_load_served": p_served, + "p_load_shed": p_shed, + "load_shed_fraction": shed_fraction, + "p_load_shed_total": cp.sum(p_shed, axis=0), + "energy_not_served_by_load": cp.sum(p_shed, axis=1), + "energy_not_served": cp.sum(p_shed), + "load_shedding_cost": cp.sum(p_shed), + } + variables = { + "Pg": pg, + "p_flows": flow, + "b": battery, + "soc": soc, + "p_nd": renewable, + "p_hvdc_in": hvdc_in, + "p_hvdc_out": hvdc_out, + "load_shed_fraction": shed_fraction, + } + variable_projections = { + name: _interval(name, tuple(variable.shape[:-1])) + for name, variable in variables.items() + if name != "soc" + } + variable_projections["soc"] = ResultProjectionSpec( + "soc", (1,), (1,), "post_step_boundaries" + ) + expression_projections = { + "p_net": _interval("p_net", (2,)), + "storage_cost": _horizon("storage_cost", ()), + "p_load": _interval("p_load", (2,)), + "q_load": _interval("q_load", (2,)), + "p_load_served": _interval("p_load_served", (2,)), + "p_load_shed": _interval("p_load_shed", (1,)), + "load_shed_fraction": _interval("load_shed_fraction", (1,)), + "p_load_shed_total": _interval("p_load_shed_total", ()), + "energy_not_served_by_load": _horizon("energy_not_served_by_load", (1,)), + "energy_not_served": _horizon("energy_not_served", ()), + "load_shedding_cost": _horizon("load_shedding_cost", ()), + } + data = { + "baseMVA": 100.0, + "T": horizon, + "ns": 1, + "storage_device_ids": np.array(["battery"], dtype=object), + "storage_device_id_is_explicit": np.array([True]), + "storage_terminal_soc": np.array([12.0]), + "nnd": 1, + "nd_available": np.array([[7.0], [8.0], [9.0]])[:horizon], + "n_hvdc": 1, + "nload": 2, + "nsheddable": 1, + } + problem = cp.Problem(cp.Minimize(cp.sum_squares(pg))) + return OPFBuild( + problem, + variables, + data, + "lossy_dc", + True, + expressions=expressions, + temporal_assembly="vectorized", + result_projections=ResultProjectionRegistry( + variables=variable_projections, + expressions=expression_projections, + ), + ) + + +def _ac_vectorized_build(*, solved_values: bool = True) -> OPFBuild: + horizon = 1 + nb = 2 + pg = cp.Variable((1, horizon), name="Pg") + qg = cp.Variable((1, horizon), name="Qg") + voltage = cp.Variable((nb, 1, horizon), name="v") + angle = cp.Variable((nb, 1, horizon), name="theta") + if solved_values: + _assign(pg, np.array([[0.5]])) + _assign(qg, np.array([[0.1]])) + _assign(voltage, np.array([[[1.0]], [[1.02]]])) + _assign(angle, np.array([[[0.0]], [[0.1]]])) + expressions = { + "p_net": cp.vstack((pg[0, :], -pg[0, :])), + "q_net": cp.vstack((qg[0, :], -qg[0, :])), + "branch_p_from_pu": pg, + "branch_q_from_pu": qg, + "branch_p_to_pu": -0.95 * pg, + "branch_q_to_pu": -0.9 * qg, + } + projections = ResultProjectionRegistry( + variables={ + "Pg": _interval("Pg", (1,)), + "Qg": _interval("Qg", (1,)), + "v": ResultProjectionSpec("v", (nb, 1), (nb,), "interval"), + "theta": ResultProjectionSpec("theta", (nb, 1), (nb,), "interval"), + }, + expressions={ + name: _interval(name, (nb,) if name in {"p_net", "q_net"} else (1,)) + for name in expressions + }, + ) + return OPFBuild( + cp.Problem(cp.Minimize(cp.sum_squares(pg))), + {"Pg": pg, "Qg": qg, "v": voltage, "theta": angle}, + {"baseMVA": 100.0, "T": horizon}, + "ac", + False, + expressions=expressions, + temporal_assembly="vectorized", + result_projections=projections, + ) + + +def test_vectorized_lossy_results_restore_complete_public_time_first_contract(): + build = _lossy_vectorized_build() + + results = extract_results(build) + + assert results["Pg"].shape == (3, 2) + assert results["p_flows"].shape == (3, 1) + assert results["p_net"].shape == (3, 2) + assert results["b"].shape == (3, 1) + assert results["soc"].shape == (3, 1) + np.testing.assert_array_equal(results["soc"][:, 0], [11.0, 9.0, 12.0]) + np.testing.assert_array_equal(results["storage_terminal_deviation"], [0.0]) + assert results["p_nd"].shape == (3, 1) + np.testing.assert_array_equal(results["curtailment"][:, 0], [3.0, 3.0, 3.0]) + assert results["p_hvdc_in"].shape == (3, 1) + np.testing.assert_allclose(results["hvdc_loss"][:, 0], [0.2, 0.3, 0.4]) + assert results["p_load"].shape == (3, 2) + assert results["p_load_shed"].shape == (3, 1) + assert results["p_load_shed_total"].shape == (3,) + assert results["energy_not_served_by_load"].shape == (1,) + assert np.ndim(results["energy_not_served"]) == 0 + assert np.ndim(results["storage_cost"]) == 0 + assert np.ndim(results["load_shedding_cost"]) == 0 + + +def test_vectorized_unavailable_primal_keeps_constants_and_schema_policy(): + build = _lossy_vectorized_build(solved_values=False) + + results = extract_results(build) + + assert results["Pg"] is None + assert results["p_flows"] is None + assert results["p_net"] is None + assert results["b"] is None + assert results["soc"] is None + assert results["storage_terminal_deviation"] is None + assert results["p_nd"] is None + assert results["curtailment"] is None + assert results["p_hvdc_in"] is None + assert results["hvdc_loss"] is None + assert results["p_load"].shape == (3, 2) + assert results["q_load"].shape == (3, 2) + assert results["p_load_served"] is None + assert np.isnan(results["storage_cost"]) + assert np.isnan(results["load_shedding_cost"]) + + +def test_vectorized_t1_result_axes_remain_explicit(): + build = _lossy_vectorized_build(horizon=1) + + results = extract_results(build) + + assert results["Pg"].shape == (1, 2) + assert results["p_flows"].shape == (1, 1) + assert results["b"].shape == (1, 1) + assert results["soc"].shape == (1, 1) + assert results["p_load_shed_total"].shape == (1,) + + +def test_vectorized_ac_projection_flattens_native_column_without_shape_inference(): + nb = 2 + build = _ac_vectorized_build() + + results = extract_results(build) + + assert results["Vm"].shape == (1, nb) + assert results["Va_deg"].shape == (1, nb) + assert results["branch_p_from"].shape == (1, 1) + assert results["branch_s_to"].shape == (1, 1) + + +@pytest.mark.parametrize("malformed", [False, True]) +def test_unavailable_vectorized_ac_still_validates_branch_projection(malformed): + build = _ac_vectorized_build(solved_values=False) + projections = dict(build.result_projections.expressions) + if malformed: + projections["branch_p_from_pu"] = _interval("branch_p_from_pu", (2,)) + else: + del projections["branch_p_from_pu"] + build.result_projections = ResultProjectionRegistry( + variables=build.result_projections.variables, + expressions=projections, + ) + + with pytest.raises(ValueError, match="branch_p_from_pu"): + extract_results(build) + + +def test_vectorized_extraction_rejects_missing_or_malformed_projection(): + build = _lossy_vectorized_build() + build.result_projections = ResultProjectionRegistry( + variables={ + name: projection + for name, projection in build.result_projections.variables.items() + if name != "Pg" + }, + expressions=build.result_projections.expressions, + ) + with pytest.raises(ValueError, match="Pg.*no declared"): + extract_results(build) + + build = _lossy_vectorized_build() + malformed = dict(build.result_projections.variables) + malformed["Pg"] = _interval("Pg", (3,)) + build.result_projections = ResultProjectionRegistry( + variables=malformed, + expressions=build.result_projections.expressions, + ) + with pytest.raises(ValueError, match="declares source shape"): + extract_results(build) + + build = _lossy_vectorized_build(solved_values=False) + malformed = dict(build.result_projections.variables) + malformed["Pg"] = _interval("Pg", (3,)) + build.result_projections = ResultProjectionRegistry( + variables=malformed, + expressions=build.result_projections.expressions, + ) + with pytest.raises(ValueError, match="declares source shape"): + extract_results(build) + + +@pytest.mark.parametrize("name", ["p_net", "storage_cost"]) +def test_vectorized_extraction_rejects_missing_required_expression(name): + build = _lossy_vectorized_build() + del build.expressions[name] + + with pytest.raises( + ValueError, + match=rf"missing required vectorized result expression {name!r}", + ): + extract_results(build) + + +def test_vectorized_extraction_rejects_missing_required_variable(): + build = _lossy_vectorized_build() + del build.variables["Pg"] + + with pytest.raises( + ValueError, + match="missing required vectorized result variable 'Pg'", + ): + extract_results(build) + + +def test_stepwise_scalar_expression_preserves_required_key_contract(): + build = OPFBuild( + cp.Problem(cp.Minimize(cp.Constant(0.0))), + {}, + {"baseMVA": 100.0}, + "lossy_dc", + True, + ) + + with pytest.raises(KeyError, match="required_cost"): + _solved_expression_value(build, "required_cost") + + +def test_vectorized_extraction_does_not_construct_cvxpy_variables(monkeypatch): + build = _lossy_vectorized_build() + original_variables = MappingProxyType(dict(build.variables)) + + def forbidden(*args, **kwargs): + raise AssertionError("result extraction must not create CVXPY variables") + + monkeypatch.setattr(cp, "Variable", forbidden) + results = extract_results(build) + + assert results["Pg"].shape == (3, 2) + assert all( + build.variables[name] is value for name, value in original_variables.items() + ) From 028b46e2f0af16fbff90a9bc991770f0267280a5 Mon Sep 17 00:00:00 2001 From: Bennet Meyers Date: Fri, 28 Aug 2026 11:25:53 -0700 Subject: [PATCH 24/28] feat(m14b): qualify vectorized component bounds Compare explicit inequalities with leaf bounds for storage, nondispatchable generation, load shedding, and lossy-DC HVDC using shared CLARABEL/SCIPY probes. Retain binding behavior, complete public results, independent audits, canonical structure, solver failures, pair-local fallback decisions, and clean fresh-process provenance for the authoritative run. --- .../m14_time_vectorization/M14B_PROTOCOL.md | 31 +- .../m14b_component_bounds.py | 1174 +++++++++++++++++ .../run_m14b_component_bounds.py | 228 ++++ plans/milestone-14-time-vectorization.md | 4 +- tests/test_m14b_component_bounds.py | 277 ++++ 5 files changed, 1709 insertions(+), 5 deletions(-) create mode 100644 experiments/m14_time_vectorization/m14b_component_bounds.py create mode 100644 experiments/m14_time_vectorization/run_m14b_component_bounds.py create mode 100644 tests/test_m14b_component_bounds.py diff --git a/experiments/m14_time_vectorization/M14B_PROTOCOL.md b/experiments/m14_time_vectorization/M14B_PROTOCOL.md index 346b666..3a8e575 100644 --- a/experiments/m14_time_vectorization/M14B_PROTOCOL.md +++ b/experiments/m14_time_vectorization/M14B_PROTOCOL.md @@ -5,8 +5,10 @@ M14b is open. It is authorized by the immutable M14a legacy baseline and the M14a.1 leaf-bound qualification record. The typed horizon, one-call assembly, aggregation/publication, and compatibility-result projection slices are now -implemented; the focused component-box gates are next. M14b keeps the public -stepwise/CPP path available and unchanged by default. +implemented. The reusable component-box probe harness, seven formulation-local +gates, fresh-process runner, and immutable result schema are implemented; the +clean authoritative execution is next. M14b keeps the public stepwise/CPP path +available and unchanged by default. The frozen representation decisions are: @@ -97,6 +99,26 @@ must retain binding-face evidence, public results, independent residuals, canonical dimensions/nonzeros, solver classification, and a local selection decision. No convex result authorizes AC. +The implemented matrix contains seven paired gates and emits nine local box +decisions because each storage gate qualifies power and SoC separately. Every +arm records an encoding-independent fixture digest, complete public component +results, actual component costs, independently reconstructed component/network +residuals, source and canonical structure, binding probes, timing, RSS, and +solver classification. Synthetic preferences used only to select informative +probe points are labeled and retained separately from component costs; in +particular, nondispatchable generation retains an empty component-cost schema. +Solver failures remain complete arm records with unavailable solver statistics +rather than aborting the matrix. Each authoritative arm runs in a fresh process +under a stable execution commit and source fingerprint. The immutable promoted +record is `M14B_COMPONENT_BOX_RESULTS.json`. + +The selection rule is fixed before execution: a pair selects leaf bounds only +when both arms and all binding probes are accepted and their objective, costs, +and public results agree within the frozen tolerances. Any neutral, failed, or +mismatched leaf arm selects explicit inequalities for that formulation/family +without blocking other gates or M14b. Preliminary dirty-tree runs are +diagnostic only and cannot change the production decision registry. + ## Delivery order 1. **Complete:** freeze typed temporal-field and variable-representation @@ -105,8 +127,9 @@ decision. No convex result authorizes AC. without calling scalar hooks `T` times. 3. **Complete:** implement compatibility publication and typed extraction without recreating a length-`T` CVXPY object list. -4. **Next:** run the focused component-box gates and freeze their local - decisions. +4. **Pre-execution implementation complete:** execute the focused component-box + matrix from a clean commit, promote its immutable record, and freeze the + resulting local decisions. 5. **Pending:** hand the completed assembly contract to M14c's vectorized lossy-DC builder. diff --git a/experiments/m14_time_vectorization/m14b_component_bounds.py b/experiments/m14_time_vectorization/m14b_component_bounds.py new file mode 100644 index 0000000..58529fc --- /dev/null +++ b/experiments/m14_time_vectorization/m14b_component_bounds.py @@ -0,0 +1,1174 @@ +"""Focused component-box qualification for the M14b vectorized contract. + +The paired harness changes only the candidate box representation. Both arms +retain identical component data, equations, costs, CLARABEL configuration, and +SCIPY canonicalization. These compact fixtures qualify representation; they +do not replace the formulation-level M14c equivalence runs. +""" + +from __future__ import annotations + +from dataclasses import dataclass +import hashlib +import json +import resource +import sys +import time +from types import MappingProxyType +from typing import Any, Literal, Mapping + +import cvxpy as cp +import numpy as np + + +Formulation = Literal["lossy_dc", "singlenode_dc"] +GateName = Literal["storage", "nondispatchable", "load_shedding", "hvdc"] +BoundEncoding = Literal["explicit", "leaf"] +FORMULATIONS: tuple[Formulation, ...] = ("lossy_dc", "singlenode_dc") +GATE_PAIRS: tuple[tuple[Formulation, GateName], ...] = ( + ("lossy_dc", "storage"), + ("singlenode_dc", "storage"), + ("lossy_dc", "nondispatchable"), + ("singlenode_dc", "nondispatchable"), + ("lossy_dc", "load_shedding"), + ("singlenode_dc", "load_shedding"), + ("lossy_dc", "hvdc"), +) +HORIZON = 4 +DELTA_HOURS = 1.0 +AUDIT_TOLERANCE = 2e-6 +PAIR_ABSOLUTE_TOLERANCE = 2e-5 +ACCEPTED_STATUSES = {cp.OPTIMAL, cp.OPTIMAL_INACCURATE} +CLARABEL_SOLVE_OPTIONS: Mapping[str, float | int] = MappingProxyType( + { + "max_iter": 500, + "tol_gap_abs": 1e-9, + "tol_gap_rel": 1e-9, + "tol_feas": 1e-9, + } +) + + +def _peak_rss_bytes() -> int: + raw = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss + return int(raw if sys.platform == "darwin" else raw * 1024) + + +@dataclass(frozen=True) +class CandidateBox: + """One exact time-last candidate box and its public family identity.""" + + variable_name: str + family: str + lower: np.ndarray + upper: np.ndarray + + def __post_init__(self) -> None: + lower = np.array(self.lower, dtype=float, copy=True) + upper = np.array(self.upper, dtype=float, copy=True) + if not self.variable_name or not self.family: + raise ValueError("candidate box names must be nonempty") + if lower.shape != upper.shape or lower.size == 0: + raise ValueError("candidate box faces must be nonempty and aligned") + if not np.isfinite(lower).all() or not np.isfinite(upper).all(): + raise ValueError("candidate box faces must be finite") + if np.any(lower > upper): + raise ValueError("candidate box lower face exceeds upper face") + lower.flags.writeable = False + upper.flags.writeable = False + object.__setattr__(self, "lower", lower) + object.__setattr__(self, "upper", upper) + + +@dataclass(frozen=True) +class ComponentProbeBuild: + """One build-ready component-box arm consumed by the shared harness.""" + + formulation: Formulation + gate: GateName + encoding: BoundEncoding + problem: cp.Problem + variables: Mapping[str, cp.Variable] + expressions: Mapping[str, cp.Expression] + expression_views: Mapping[str, Literal["interval", "horizon"]] + inputs: Mapping[str, object] + candidate_boxes: tuple[CandidateBox, ...] + + def __post_init__(self) -> None: + object.__setattr__(self, "variables", MappingProxyType(dict(self.variables))) + object.__setattr__( + self, "expressions", MappingProxyType(dict(self.expressions)) + ) + views = dict(self.expression_views) + if set(views) != set(self.expressions): + raise ValueError("expression views must exactly match expressions") + object.__setattr__(self, "expression_views", MappingProxyType(views)) + object.__setattr__(self, "inputs", MappingProxyType(dict(self.inputs))) + + def solve(self) -> None: + """Use the exact frozen convex solver and canonicalization backend.""" + self.problem.solve( + solver=cp.CLARABEL, + canon_backend=cp.SCIPY_CANON_BACKEND, + **CLARABEL_SOLVE_OPTIONS, + ) + + +def _candidate_variable( + box: CandidateBox, + encoding: BoundEncoding, +) -> tuple[cp.Variable, list[cp.Constraint]]: + """Construct one candidate using only the requested representation.""" + if encoding == "leaf": + return cp.Variable( + box.lower.shape, + name=box.variable_name, + bounds=[box.lower, box.upper], + ), [] + variable = cp.Variable(box.lower.shape, name=box.variable_name) + return variable, [variable >= box.lower, variable <= box.upper] + + +def _incidence(device_buses: np.ndarray, *, buses: int = 2) -> np.ndarray: + matrix = np.zeros((buses, device_buses.size)) + matrix[device_buses, np.arange(device_buses.size)] = 1.0 + return matrix + + +def _network_model( + formulation: Formulation, + injection: cp.Expression, + demand: np.ndarray, + *, + generation_upper: np.ndarray | None = None, +) -> tuple[ + dict[str, cp.Variable], + list[cp.Constraint], + cp.Expression, + cp.Expression, +]: + """Attach the same component injection to a compact DC network context.""" + if injection.shape != (2, HORIZON): + raise ValueError("network injection must have shape (2, HORIZON)") + if demand.shape != (2, HORIZON): + raise ValueError("network demand must have shape (2, HORIZON)") + total_upper = ( + np.full(HORIZON, 100.0) + if generation_upper is None + else np.asarray(generation_upper, dtype=float) + ) + if total_upper.shape != (HORIZON,): + raise ValueError("generation upper profile must have shape (HORIZON,)") + constraints: list[cp.Constraint] = [] + variables: dict[str, cp.Variable] = {} + if formulation == "singlenode_dc": + generation = cp.Variable((1, HORIZON), name="Pg") + constraints.extend((generation >= 0.0, generation <= total_upper[None, :])) + p_net = ( + cp.sum(generation, axis=0) + + cp.sum(injection, axis=0) + - np.sum(demand, axis=0) + ) + constraints.append(p_net == 0.0) + variables["Pg"] = generation + cost = 0.02 * cp.sum_squares(generation) + return variables, constraints, cost, p_net + + generation = cp.Variable((2, HORIZON), name="Pg") + flow = cp.Variable((1, HORIZON), name="p_flows") + per_bus_upper = np.broadcast_to(total_upper[None, :] / 2.0, (2, HORIZON)) + constraints.extend( + ( + generation >= 0.0, + generation <= per_bus_upper, + flow >= -50.0, + flow <= 50.0, + generation[0, :] + injection[0, :] - demand[0, :] - flow[0, :] == 0, + generation[1, :] + injection[1, :] - demand[1, :] + flow[0, :] == 0, + ) + ) + p_net = generation + injection - demand + variables.update(Pg=generation, p_flows=flow) + cost = 0.02 * cp.sum_squares(generation) + 0.001 * cp.sum_squares(flow) + return variables, constraints, cost, p_net + + +def _storage_build( + formulation: Formulation, + encoding: BoundEncoding, +) -> ComponentProbeBuild: + device_ids = np.array(["equality", "shortfall", "soft"], dtype=object) + power_rating = np.array([4.0, 3.0, 5.0]) + capacity = np.array([10.0, 8.0, 12.0]) + initial = np.array([5.0, 4.0, 6.0]) + b_box = CandidateBox( + "b", + "storage_real_power", + np.broadcast_to(-power_rating[:, None], (3, HORIZON)), + np.broadcast_to(power_rating[:, None], (3, HORIZON)), + ) + soc_box = CandidateBox( + "soc", + "storage_soc", + np.zeros((3, HORIZON + 1)), + np.broadcast_to(capacity[:, None], (3, HORIZON + 1)), + ) + b, b_constraints = _candidate_variable(b_box, encoding) + soc, soc_constraints = _candidate_variable(soc_box, encoding) + reference = np.array( + [[2.0, -2.0, 1.0, -1.0], [1.0, 1.0, -1.0, -1.0], [2.0, 1.0, -1.0, 0.0]] + ) + constraints = [*b_constraints, *soc_constraints] + constraints.extend( + ( + soc[:, 0] == initial, + soc[:, 1:] == soc[:, :-1] - DELTA_HOURS * b, + soc[0, -1] == 5.0, + soc[1, -1] >= 3.0, + ) + ) + aging_cost = 0.02 * DELTA_HOURS * cp.sum(cp.abs(b)) + terminal_cost = 2.0 * cp.square(soc[2, -1] - 5.0) + injection = _incidence(np.array([0, 1, 1])) @ b + demand = np.array([[8.0, 9.0, 8.0, 10.0], [6.0, 5.0, 7.0, 6.0]], dtype=float) + network_variables, network_constraints, network_cost, p_net = _network_model( + formulation, injection, demand + ) + constraints.extend(network_constraints) + objective = ( + network_cost + cp.sum_squares(b - reference) + aging_cost + terminal_cost + ) + return ComponentProbeBuild( + formulation, + "storage", + encoding, + cp.Problem(cp.Minimize(objective), constraints), + {"b": b, "soc": soc, **network_variables}, + { + "storage_cost": aging_cost, + "storage_terminal_cost": terminal_cost, + "storage_injection": injection, + "storage_terminal_deviation": soc[:, -1] - np.array([5.0, 3.0, 5.0]), + "p_net": p_net, + }, + { + "storage_cost": "horizon", + "storage_terminal_cost": "horizon", + "storage_injection": "interval", + "storage_terminal_deviation": "horizon", + "p_net": "interval", + }, + { + "device_ids": device_ids, + "power_rating": power_rating, + "capacity": capacity, + "initial_soc": initial, + "terminal_target": np.array([5.0, 3.0, 5.0]), + "reference": reference, + "demand": demand, + }, + (b_box, soc_box), + ) + + +def _nondispatchable_build( + formulation: Formulation, + encoding: BoundEncoding, +) -> ComponentProbeBuild: + device_ids = np.array(["solar-a", "wind-b", "solar-c"], dtype=object) + buses = np.array([0, 1, 1]) + rating = np.array([4.0, 3.0, 5.0]) + availability = np.array( + [[0.0, 2.0, 6.0, 1.0], [5.0, 1.0, 3.0, 6.0], [2.0, 4.0, 0.0, 5.0]] + ) + effective_upper = np.minimum(availability, rating[:, None]) + box = CandidateBox( + "p_nd", + "nondispatchable_real_power", + np.zeros_like(effective_upper), + effective_upper, + ) + if encoding == "explicit": + power = cp.Variable(box.lower.shape, name=box.variable_name) + constraints = [ + power >= 0.0, + power <= availability, + power <= rating[:, None], + ] + else: + power, box_constraints = _candidate_variable(box, encoding) + constraints = list(box_constraints) + injection = _incidence(buses) @ power + demand = np.array([[12.0, 13.0, 11.0, 14.0], [10.0, 9.0, 12.0, 10.0]], dtype=float) + network_variables, network_constraints, network_cost, p_net = _network_model( + formulation, injection, demand + ) + constraints.extend(network_constraints) + curtailment = availability - power + probe_preference = 3.0 * DELTA_HOURS * cp.sum(curtailment) + 1e-3 * cp.sum_squares( + power + ) + objective = network_cost + probe_preference + return ComponentProbeBuild( + formulation, + "nondispatchable", + encoding, + cp.Problem(cp.Minimize(objective), constraints), + {"p_nd": power, **network_variables}, + { + "curtailment": curtailment, + "nondispatchable_preference_probe_only": probe_preference, + "nondispatchable_injection": injection, + "p_net": p_net, + }, + { + "curtailment": "interval", + "nondispatchable_preference_probe_only": "horizon", + "nondispatchable_injection": "interval", + "p_net": "interval", + }, + { + "device_ids": device_ids, + "device_buses": buses, + "availability": availability, + "rating": rating, + "effective_upper": effective_upper, + "demand": demand, + }, + (box,), + ) + + +def _load_shedding_build( + formulation: Formulation, + encoding: BoundEncoding, +) -> ComponentProbeBuild: + device_ids = np.array(["industrial", "commercial"], dtype=object) + buses = np.array([0, 1]) + load = np.array([[8.0, 10.0, 12.0, 9.0], [5.0, 7.0, 6.0, 8.0]]) + reactive_load = np.array([[2.4, 3.0, 3.6, 2.7], [1.0, 1.4, 1.2, 1.6]], dtype=float) + eligibility = np.array([[0.0, 1.0, 1.0, 1.0], [1.0, 1.0, 0.0, 1.0]]) + maximum_fraction = np.array([0.5, 0.25]) + upper = maximum_fraction[:, None] * eligibility + box = CandidateBox( + "load_shed_fraction", + "load_shed_fraction", + np.zeros_like(upper), + upper, + ) + fraction, box_constraints = _candidate_variable(box, encoding) + constraints = list(box_constraints) + shed = cp.multiply(load, fraction) + served = load - shed + shed_total = cp.sum(shed, axis=0) + ens_by_load = DELTA_HOURS * cp.sum(shed, axis=1) + ens = cp.sum(ens_by_load) + injection = -(_incidence(buses) @ served) + demand = np.zeros((2, HORIZON)) + total_load = np.sum(load, axis=0) + generation_upper = total_load - np.array([0.5, 1.0, 1.0, 1.0]) + network_variables, network_constraints, network_cost, p_net = _network_model( + formulation, + injection, + demand, + generation_upper=generation_upper, + ) + constraints.extend(network_constraints) + costs = np.array([100.0, 180.0]) + shedding_cost = DELTA_HOURS * cp.sum(cp.multiply(costs[:, None], shed)) + objective = network_cost + shedding_cost + 1e-4 * cp.sum_squares(fraction) + return ComponentProbeBuild( + formulation, + "load_shedding", + encoding, + cp.Problem(cp.Minimize(objective), constraints), + {"load_shed_fraction": fraction, **network_variables}, + { + "p_load": cp.Constant(load), + "q_load": cp.Constant(reactive_load), + "p_load_shed": shed, + "p_load_shed_total": shed_total, + "p_load_served": served, + "energy_not_served_by_load": ens_by_load, + "energy_not_served": ens, + "load_shedding_cost": shedding_cost, + "load_injection": injection, + "p_net": p_net, + }, + { + "p_load": "interval", + "q_load": "interval", + "p_load_shed": "interval", + "p_load_shed_total": "interval", + "p_load_served": "interval", + "energy_not_served_by_load": "horizon", + "energy_not_served": "horizon", + "load_shedding_cost": "horizon", + "load_injection": "interval", + "p_net": "interval", + }, + { + "device_ids": device_ids, + "device_buses": buses, + "p_load": load, + "q_load": reactive_load, + "eligibility": eligibility, + "maximum_fraction": maximum_fraction, + "cost_per_mwh": costs, + "generation_upper": generation_upper, + "demand": demand, + }, + (box,), + ) + + +def _hvdc_build(encoding: BoundEncoding) -> ComponentProbeBuild: + device_ids = np.array( + ["positive", "negative", "straddling", "degenerate", "varying"], + dtype=object, + ) + lower = np.array( + [ + [1.0, 1.0, 1.5, 1.5], + [-5.0, -4.0, -4.0, -3.0], + [-3.0] * 4, + [2.0] * 4, + [0.0, 1.0, 2.0, 1.0], + ] + ) + upper = np.array( + [ + [4.0, 4.5, 4.5, 5.0], + [-1.0, -1.0, -0.5, -0.5], + [3.0] * 4, + [2.0] * 4, + [2.0, 3.0, 4.0, 2.0], + ] + ) + loss_fraction = np.array([0.05, 0.08, 0.1, 0.02, 0.03]) + box = CandidateBox("p_hvdc_in", "hvdc_input_power", lower, upper) + p_in, box_constraints = _candidate_variable(box, encoding) + p_out = cp.Variable((5, HORIZON), name="p_hvdc_out") + constraints = list(box_constraints) + constraints.extend( + ( + p_out[0, :] == -p_in[0, :] / (1.0 - loss_fraction[0]), + p_out[1, :] == -(1.0 - loss_fraction[1]) * p_in[1, :], + p_out[2, :] == -p_in[2, :], + p_out[3, :] == -p_in[3, :] / (1.0 - loss_fraction[3]), + p_out[4, :] == -p_in[4, :] / (1.0 - loss_fraction[4]), + ) + ) + from_incidence = _incidence(np.zeros(5, dtype=int)) + to_incidence = _incidence(np.ones(5, dtype=int)) + injection = from_incidence @ p_in + to_incidence @ p_out + demand = np.array([[14.0, 14.0, 15.0, 15.0], [11.0, 12.0, 11.0, 12.0]], dtype=float) + network_variables, network_constraints, network_cost, p_net = _network_model( + "lossy_dc", injection, demand + ) + constraints.extend(network_constraints) + desired = np.where(np.indices(lower.shape).sum(axis=0) % 2 == 0, lower, upper) + cost = 0.01 * cp.sum_squares(p_in) + 0.02 * cp.sum(cp.abs(p_in)) + objective = network_cost + cp.sum_squares(p_in - desired) + cost + return ComponentProbeBuild( + "lossy_dc", + "hvdc", + encoding, + cp.Problem(cp.Minimize(objective), constraints), + {"p_hvdc_in": p_in, "p_hvdc_out": p_out, **network_variables}, + { + "hvdc_loss": -(p_in + p_out), + "hvdc_cost": cost, + "hvdc_injection": injection, + "p_net": p_net, + }, + { + "hvdc_loss": "interval", + "hvdc_cost": "horizon", + "hvdc_injection": "interval", + "p_net": "interval", + }, + { + "device_ids": device_ids, + "loss_fraction": loss_fraction, + "desired": desired, + "demand": demand, + "direction": np.array( + ["positive", "negative", "straddling", "positive", "positive"], + dtype=object, + ), + }, + (box,), + ) + + +def build_probe( + formulation: Formulation, + gate: GateName, + encoding: BoundEncoding, +) -> ComponentProbeBuild: + """Build one arm from the frozen formulation/component registry.""" + if (formulation, gate) not in GATE_PAIRS: + raise ValueError(f"gate {gate!r} does not apply to {formulation!r}") + if encoding not in {"explicit", "leaf"}: + raise ValueError("unsupported bound encoding") + if gate == "storage": + return _storage_build(formulation, encoding) + if gate == "nondispatchable": + return _nondispatchable_build(formulation, encoding) + if gate == "load_shedding": + return _load_shedding_build(formulation, encoding) + return _hvdc_build(encoding) + + +def _source_structure(build: ComponentProbeBuild) -> dict[str, Any]: + metrics = build.problem.size_metrics + constraints = build.problem.constraints + return { + "problem_is_dcp": build.problem.is_dcp(), + "objective_is_dcp": build.problem.objective.is_dcp(), + "all_constraints_dcp": all(item.is_dcp() for item in constraints), + "variable_objects": len(build.problem.variables()), + "constraint_objects": len(constraints), + "equality_objects": sum( + isinstance(item, cp.constraints.Equality) for item in constraints + ), + "explicit_inequality_objects": sum( + isinstance(item, cp.constraints.Inequality) for item in constraints + ), + "scalar_variables": int(metrics.num_scalar_variables), + "scalar_equalities": int(metrics.num_scalar_eq_constr), + "explicit_scalar_inequalities": int(metrics.num_scalar_leq_constr), + "variable_shapes": { + name: list(variable.shape) for name, variable in build.variables.items() + }, + } + + +def _canonical_structure(problem: cp.Problem) -> dict[str, Any]: + data, chain, _inverse = problem.get_problem_data( + cp.CLARABEL, + canon_backend=cp.SCIPY_CANON_BACKEND, + ) + dimensions = data["dims"] + matrix = data["A"] + quadratic = data.get("P") + return { + "backend": "SCIPY", + "canonical_variables": int(data["c"].shape[0]), + "equality_rows": int(dimensions.zero), + "nonnegative_rows": int(dimensions.nonneg), + "soc_dimensions": [int(value) for value in dimensions.soc], + "coefficient_rows": int(matrix.shape[0]), + "coefficient_columns": int(matrix.shape[1]), + "coefficient_nonzeros": int(matrix.nnz), + "quadratic_nonzeros": 0 if quadratic is None else int(quadratic.nnz), + "reductions": [type(item).__name__ for item in chain.reductions], + } + + +def _values(build: ComponentProbeBuild) -> dict[str, np.ndarray]: + return { + name: np.asarray(variable.value, dtype=float) + for name, variable in build.variables.items() + if variable.value is not None + } + + +def _expression_values(build: ComponentProbeBuild) -> dict[str, np.ndarray]: + return { + name: np.asarray(expression.value, dtype=float) + for name, expression in build.expressions.items() + if expression.value is not None + } + + +def _fixture_sha256(build: ComponentProbeBuild) -> str: + """Bind all exogenous arrays and candidate faces independent of encoding.""" + digest = hashlib.sha256() + digest.update(f"{build.formulation}/{build.gate}".encode()) + for name, raw_value in sorted(build.inputs.items()): + value = np.asarray(raw_value) + digest.update(name.encode()) + digest.update(str(value.shape).encode()) + digest.update(value.dtype.str.encode()) + if value.dtype.kind in {"O", "U", "S"}: + digest.update(json.dumps(value.tolist(), separators=(",", ":")).encode()) + else: + digest.update(np.ascontiguousarray(value).tobytes()) + for box in build.candidate_boxes: + digest.update(box.family.encode()) + digest.update(box.variable_name.encode()) + digest.update(np.ascontiguousarray(box.lower).tobytes()) + digest.update(np.ascontiguousarray(box.upper).tobytes()) + return digest.hexdigest() + + +def _box_residuals( + build: ComponentProbeBuild, + values: Mapping[str, np.ndarray], +) -> dict[str, float]: + residuals: dict[str, float] = {} + for box in build.candidate_boxes: + value = values[box.variable_name] + residuals[f"{box.family}_box_abs"] = float( + max(0.0, np.max(box.lower - value), np.max(value - box.upper)) + ) + return residuals + + +def _network_residuals( + build: ComponentProbeBuild, + values: Mapping[str, np.ndarray], + injection: np.ndarray, + published_p_net: np.ndarray, +) -> dict[str, float]: + demand = np.asarray(build.inputs["demand"], dtype=float) + generation = values["Pg"] + if build.formulation == "singlenode_dc": + expected_p_net = ( + np.sum(generation, axis=0) + + np.sum(injection, axis=0) + - np.sum(demand, axis=0) + ) + balance = expected_p_net + else: + flow = values["p_flows"][0, :] + expected_p_net = generation + injection - demand + balance = np.vstack( + ( + expected_p_net[0, :] - flow, + expected_p_net[1, :] + flow, + ) + ) + return { + "active_balance_abs": float(np.max(np.abs(balance))), + "p_net_reconstruction_abs": float( + np.max(np.abs(expected_p_net - published_p_net)) + ), + } + + +def _network_cost_value( + build: ComponentProbeBuild, + values: Mapping[str, np.ndarray], +) -> float: + cost = 0.02 * np.sum(values["Pg"] ** 2) + if build.formulation == "lossy_dc": + cost += 0.001 * np.sum(values["p_flows"] ** 2) + return float(cost) + + +def _objective_residual(build: ComponentProbeBuild, reconstructed: float) -> float: + objective = build.problem.value + if objective is None or not np.isfinite(float(objective)): + return float("inf") + return abs(float(objective) - reconstructed) + + +def _audit( + build: ComponentProbeBuild, + values: Mapping[str, np.ndarray], + expressions: Mapping[str, np.ndarray], +) -> dict[str, float]: + residuals = _box_residuals(build, values) + if build.gate == "storage": + b = values["b"] + soc = values["soc"] + initial = np.asarray(build.inputs["initial_soc"], dtype=float) + targets = np.asarray(build.inputs["terminal_target"], dtype=float) + residuals.update( + storage_initial_abs=float(np.max(np.abs(soc[:, 0] - initial))), + storage_recurrence_abs=float( + np.max(np.abs(soc[:, 1:] - soc[:, :-1] + DELTA_HOURS * b)) + ), + equality_terminal_abs=float(abs(soc[0, -1] - targets[0])), + shortfall_terminal_abs=float(max(0.0, targets[1] - soc[1, -1])), + storage_cost_abs=float( + abs(expressions["storage_cost"] - 0.02 * np.sum(np.abs(b))) + ), + storage_terminal_cost_abs=float( + abs( + expressions["storage_terminal_cost"] + - 2.0 * (soc[2, -1] - targets[2]) ** 2 + ) + ), + ) + reconstructed_objective = ( + _network_cost_value(build, values) + + np.sum((b - np.asarray(build.inputs["reference"], dtype=float)) ** 2) + + float(expressions["storage_cost"]) + + float(expressions["storage_terminal_cost"]) + ) + residuals["objective_reconstruction_abs"] = _objective_residual( + build, float(reconstructed_objective) + ) + injection = _incidence(np.array([0, 1, 1])) @ b + residuals["component_injection_abs"] = float( + np.max(np.abs(injection - expressions["storage_injection"])) + ) + residuals.update( + _network_residuals(build, values, injection, expressions["p_net"]) + ) + return residuals + + if build.gate == "nondispatchable": + power = values["p_nd"] + availability = np.asarray(build.inputs["availability"], dtype=float) + rating = np.asarray(build.inputs["rating"], dtype=float) + curtailment = availability - power + residuals.update( + availability_abs=float(max(0.0, np.max(power - availability))), + rating_abs=float(max(0.0, np.max(power - rating[:, None]))), + curtailment_abs=float( + np.max(np.abs(curtailment - expressions["curtailment"])) + ), + curtailment_nonnegative_abs=float(max(0.0, -np.min(curtailment))), + nondispatchable_preference_probe_only_abs=float( + abs( + expressions["nondispatchable_preference_probe_only"] + - ( + 3.0 * DELTA_HOURS * np.sum(curtailment) + + 1e-3 * np.sum(power**2) + ) + ) + ), + ) + reconstructed_objective = _network_cost_value(build, values) + float( + expressions["nondispatchable_preference_probe_only"] + ) + residuals["objective_reconstruction_abs"] = _objective_residual( + build, float(reconstructed_objective) + ) + injection = ( + _incidence(np.asarray(build.inputs["device_buses"], dtype=int)) @ power + ) + residuals["component_injection_abs"] = float( + np.max(np.abs(injection - expressions["nondispatchable_injection"])) + ) + residuals.update( + _network_residuals(build, values, injection, expressions["p_net"]) + ) + return residuals + + if build.gate == "load_shedding": + fraction = values["load_shed_fraction"] + load = np.asarray(build.inputs["p_load"], dtype=float) + reactive_load = np.asarray(build.inputs["q_load"], dtype=float) + eligibility = np.asarray(build.inputs["eligibility"], dtype=float) + maximum = np.asarray(build.inputs["maximum_fraction"], dtype=float) + shed = load * fraction + served = load - shed + cost = np.asarray(build.inputs["cost_per_mwh"], dtype=float) + residuals.update( + eligibility_abs=float( + max(0.0, np.max(fraction - maximum[:, None] * eligibility)) + ), + q_load_reconstruction_abs=float( + np.max(np.abs(reactive_load - expressions["q_load"])) + ), + ineligible_fraction_abs=float(np.max(np.abs(fraction[eligibility == 0.0]))), + shed_reconstruction_abs=float( + np.max(np.abs(shed - expressions["p_load_shed"])) + ), + shed_total_reconstruction_abs=float( + np.max(np.abs(np.sum(shed, axis=0) - expressions["p_load_shed_total"])) + ), + served_reconstruction_abs=float( + np.max(np.abs(served - expressions["p_load_served"])) + ), + energy_not_served_by_load_abs=float( + np.max( + np.abs( + DELTA_HOURS * np.sum(shed, axis=1) + - expressions["energy_not_served_by_load"] + ) + ) + ), + energy_not_served_abs=float( + abs(DELTA_HOURS * np.sum(shed) - expressions["energy_not_served"]) + ), + shedding_cost_abs=float( + abs( + expressions["load_shedding_cost"] + - DELTA_HOURS * np.sum(cost[:, None] * shed) + ) + ), + ) + reconstructed_objective = ( + _network_cost_value(build, values) + + float(expressions["load_shedding_cost"]) + + 1e-4 * np.sum(fraction**2) + ) + residuals["objective_reconstruction_abs"] = _objective_residual( + build, float(reconstructed_objective) + ) + injection = -( + _incidence(np.asarray(build.inputs["device_buses"], dtype=int)) @ served + ) + residuals["component_injection_abs"] = float( + np.max(np.abs(injection - expressions["load_injection"])) + ) + residuals.update( + _network_residuals(build, values, injection, expressions["p_net"]) + ) + return residuals + + p_in = values["p_hvdc_in"] + p_out = values["p_hvdc_out"] + loss_fraction = np.asarray(build.inputs["loss_fraction"], dtype=float) + expected_out = np.vstack( + ( + -p_in[0, :] / (1.0 - loss_fraction[0]), + -(1.0 - loss_fraction[1]) * p_in[1, :], + -p_in[2, :], + -p_in[3, :] / (1.0 - loss_fraction[3]), + -p_in[4, :] / (1.0 - loss_fraction[4]), + ) + ) + loss = -(p_in + p_out) + residuals.update( + hvdc_coupling_abs=float(np.max(np.abs(p_out - expected_out))), + hvdc_loss_abs=float(np.max(np.abs(loss - expressions["hvdc_loss"]))), + hvdc_loss_nonnegative_abs=float(max(0.0, -np.min(loss))), + hvdc_cost_abs=float( + abs( + expressions["hvdc_cost"] + - 0.01 * np.sum(p_in**2) + - 0.02 * np.sum(np.abs(p_in)) + ) + ), + ) + reconstructed_objective = ( + _network_cost_value(build, values) + + np.sum((p_in - np.asarray(build.inputs["desired"], dtype=float)) ** 2) + + float(expressions["hvdc_cost"]) + ) + residuals["objective_reconstruction_abs"] = _objective_residual( + build, float(reconstructed_objective) + ) + injection = ( + _incidence(np.zeros(5, dtype=int)) @ p_in + + _incidence(np.ones(5, dtype=int)) @ p_out + ) + residuals["component_injection_abs"] = float( + np.max(np.abs(injection - expressions["hvdc_injection"])) + ) + residuals.update(_network_residuals(build, values, injection, expressions["p_net"])) + return residuals + + +def _binding_probe( + box: CandidateBox, + encoding: BoundEncoding, +) -> dict[str, Any]: + """Drive both nondegenerate faces and every fixed coordinate exactly.""" + variable, constraints = _candidate_variable(box, encoding) + parity = np.indices(box.lower.shape).sum(axis=0) % 2 == 0 + fixed = box.lower == box.upper + desired = np.where(parity, box.lower, box.upper) + width = np.maximum(box.upper - box.lower, 1.0) + target = np.where(parity, box.lower - width, box.upper + width) + problem = cp.Problem(cp.Minimize(cp.sum_squares(variable - target)), constraints) + exception = None + try: + problem.solve( + solver=cp.CLARABEL, + canon_backend=cp.SCIPY_CANON_BACKEND, + **CLARABEL_SOLVE_OPTIONS, + ) + except Exception as error: + exception = f"{type(error).__name__}: {error}" + value = None if variable.value is None else np.asarray(variable.value, dtype=float) + residual = None if value is None else float(np.max(np.abs(value - desired))) + stats = problem.solver_stats + return { + "family": box.family, + "variable": box.variable_name, + "status": problem.status, + "solver": None if stats is None else stats.solver_name, + "canonicalization_backend": "SCIPY", + "exception": exception, + "lower_face_coordinates": int(np.count_nonzero(parity & ~fixed)), + "upper_face_coordinates": int(np.count_nonzero(~parity & ~fixed)), + "fixed_coordinates": int(np.count_nonzero(fixed)), + "maximum_face_residual": residual, + "accepted": exception is None + and problem.status in ACCEPTED_STATUSES + and residual is not None + and residual <= AUDIT_TOLERANCE, + "values": None if value is None else value.tolist(), + } + + +def run_arm( + formulation: Formulation, + gate: GateName, + encoding: BoundEncoding, +) -> dict[str, Any]: + """Build, characterize, solve, extract, and audit one shared-harness arm.""" + started = time.perf_counter() + build = build_probe(formulation, gate, encoding) + construction = time.perf_counter() - started + rss_after_construction = _peak_rss_bytes() + source = _source_structure(build) + started = time.perf_counter() + canonical = _canonical_structure(build.problem) + canonicalization = time.perf_counter() - started + rss_after_canonicalization = _peak_rss_bytes() + exception = None + started = time.perf_counter() + try: + build.solve() + except Exception as error: + exception = f"{type(error).__name__}: {error}" + solve_seconds = time.perf_counter() - started + rss_after_solve = _peak_rss_bytes() + values = _values(build) + expression_values = _expression_values(build) + complete = set(values) == set(build.variables) and set(expression_values) == set( + build.expressions + ) + finite = complete and all( + np.isfinite(value).all() + for value in (*values.values(), *expression_values.values()) + ) + residuals = _audit(build, values, expression_values) if finite else {} + objective = build.problem.value + finite_objective = objective is not None and np.isfinite(float(objective)) + status = build.problem.status + accepted = ( + exception is None + and status in ACCEPTED_STATUSES + and finite + and finite_objective + and bool(residuals) + and max(residuals.values()) <= AUDIT_TOLERANCE + ) + if exception is not None: + classification = "solver_failure" + elif status in {cp.INFEASIBLE, cp.INFEASIBLE_INACCURATE}: + classification = "solver_certified_infeasible" + elif accepted: + classification = "accepted" + else: + classification = "unusable_primal" + public_results = { + name: np.moveaxis(value, -1, 0).tolist() + for name, value in values.items() + if value.ndim > 0 and value.shape[-1] == HORIZON + } + for name, value in expression_values.items(): + view = build.expression_views[name] + if view == "interval": + if value.ndim == 0 or value.shape[-1] != HORIZON: + raise ValueError( + f"interval expression {name!r} has invalid shape {value.shape}" + ) + if name in public_results: + raise ValueError(f"duplicate public result source {name!r}") + public_results[name] = np.moveaxis(value, -1, 0).tolist() + elif not name.endswith("cost") and not name.endswith("_probe_only"): + if name in public_results: + raise ValueError(f"duplicate public result source {name!r}") + public_results[name] = value.tolist() + if "soc" in values: + public_results["soc"] = np.moveaxis(values["soc"][:, 1:], -1, 0).tolist() + scalar_costs = { + name: float(value) + for name, value in expression_values.items() + if value.shape == () and name.endswith("cost") + } + probe_only_objective_terms = { + name: float(value) + for name, value in expression_values.items() + if value.shape == () and name.endswith("_probe_only") + } + stats = build.problem.solver_stats + return { + "formulation": formulation, + "gate": gate, + "encoding": encoding, + "status": status, + "classification": classification, + "accepted": accepted, + "exception": exception, + "objective": float(objective) if finite_objective else None, + "component_costs": scalar_costs, + "probe_only_objective_terms": probe_only_objective_terms, + "public_results": public_results, + "residuals": residuals, + "binding_probes": [ + _binding_probe(box, encoding) for box in build.candidate_boxes + ], + "source_structure": source, + "canonical_structure": canonical, + "timing_seconds": { + "construction": construction, + "canonicalization": canonicalization, + "solve": solve_seconds, + }, + "process_peak_rss_bytes": { + "after_construction": rss_after_construction, + "after_canonicalization": rss_after_canonicalization, + "after_solve": rss_after_solve, + }, + "solver": None if stats is None else stats.solver_name, + "solver_iterations": None if stats is None else stats.num_iters, + "solve_time": None if stats is None else stats.solve_time, + "device_ids": np.asarray(build.inputs["device_ids"], dtype=object).tolist(), + "fixture_sha256": _fixture_sha256(build), + } + + +def compare_pair(explicit: dict[str, Any], leaf: dict[str, Any]) -> dict[str, Any]: + """Apply one formulation-local explicit-versus-leaf equivalence gate.""" + if (explicit["formulation"], explicit["gate"]) != ( + leaf["formulation"], + leaf["gate"], + ): + raise ValueError("component qualification pair identity mismatch") + public_names = set(explicit["public_results"]) + schemas_match = public_names == set(leaf["public_results"]) + public_residuals = { + name: float( + np.max( + np.abs( + np.asarray(explicit["public_results"][name], dtype=float) + - np.asarray(leaf["public_results"][name], dtype=float) + ) + ) + ) + for name in sorted(public_names.intersection(leaf["public_results"])) + } + cost_names = set(explicit["component_costs"]) + cost_schemas_match = cost_names == set(leaf["component_costs"]) + cost_residuals = { + name: abs( + float(explicit["component_costs"][name]) + - float(leaf["component_costs"][name]) + ) + for name in sorted(cost_names.intersection(leaf["component_costs"])) + } + probe_term_names = set(explicit["probe_only_objective_terms"]) + probe_term_schemas_match = probe_term_names == set( + leaf["probe_only_objective_terms"] + ) + probe_term_residuals = { + name: abs( + float(explicit["probe_only_objective_terms"][name]) + - float(leaf["probe_only_objective_terms"][name]) + ) + for name in sorted( + probe_term_names.intersection(leaf["probe_only_objective_terms"]) + ) + } + objective_residual = ( + None + if explicit["objective"] is None or leaf["objective"] is None + else abs(float(explicit["objective"]) - float(leaf["objective"])) + ) + explicit_probes = {probe["family"]: probe for probe in explicit["binding_probes"]} + leaf_probes = {probe["family"]: probe for probe in leaf["binding_probes"]} + probe_schemas_match = set(explicit_probes) == set(leaf_probes) + probe_residuals = { + family: float( + np.max( + np.abs( + np.asarray(explicit_probes[family]["values"], dtype=float) + - np.asarray(leaf_probes[family]["values"], dtype=float) + ) + ) + ) + for family in sorted(set(explicit_probes).intersection(leaf_probes)) + if explicit_probes[family]["values"] is not None + and leaf_probes[family]["values"] is not None + } + binding_passed = ( + probe_schemas_match + and all(probe["accepted"] for probe in explicit_probes.values()) + and all(probe["accepted"] for probe in leaf_probes.values()) + and len(probe_residuals) == len(explicit_probes) + and max(probe_residuals.values(), default=0.0) <= PAIR_ABSOLUTE_TOLERANCE + ) + both_accepted = bool(explicit["accepted"] and leaf["accepted"]) + fixture_match = explicit["fixture_sha256"] == leaf["fixture_sha256"] + equivalent = ( + both_accepted + and fixture_match + and schemas_match + and cost_schemas_match + and probe_term_schemas_match + and binding_passed + and objective_residual is not None + and objective_residual <= PAIR_ABSOLUTE_TOLERANCE + and max(public_residuals.values(), default=0.0) <= PAIR_ABSOLUTE_TOLERANCE + and max(cost_residuals.values(), default=0.0) <= PAIR_ABSOLUTE_TOLERANCE + and max(probe_term_residuals.values(), default=0.0) <= PAIR_ABSOLUTE_TOLERANCE + ) + families = sorted(explicit_probes) + return { + "formulation": explicit["formulation"], + "gate": explicit["gate"], + "box_families": families, + "both_accepted": both_accepted, + "fixture_sha256": explicit["fixture_sha256"] if fixture_match else None, + "fixture_fingerprints_match": fixture_match, + "result_schemas_match": schemas_match, + "cost_schemas_match": cost_schemas_match, + "probe_only_objective_term_schemas_match": probe_term_schemas_match, + "binding_probes_passed": binding_passed, + "equivalent": equivalent, + "objective_absolute_residual": objective_residual, + "component_cost_absolute_residuals": cost_residuals, + "probe_only_objective_term_absolute_residuals": probe_term_residuals, + "public_result_absolute_residuals": public_residuals, + "binding_probe_absolute_residuals": probe_residuals, + "explicit": explicit, + "leaf": leaf, + } + + +def pair_decisions(pair: Mapping[str, Any]) -> dict[str, dict[str, Any]]: + """Freeze one local decision per candidate box family.""" + passed = bool(pair["equivalent"]) + return { + family: { + "leaf_bounds_qualified": passed, + "selected_representation": "leaf" if passed else "explicit", + "reason": ( + "paired model and binding probe passed" + if passed + else "paired gate regressed; retain explicit inequalities" + ), + } + for family in pair["box_families"] + } + + +def run_all() -> dict[str, Any]: + """Run all seven gates and retain nine formulation/family decisions.""" + pairs = [] + decisions: dict[str, dict[str, Any]] = {} + for formulation, gate in GATE_PAIRS: + pair = compare_pair( + run_arm(formulation, gate, "explicit"), + run_arm(formulation, gate, "leaf"), + ) + pairs.append(pair) + for family, decision in pair_decisions(pair).items(): + decisions[f"{formulation}/{family}"] = decision + return { + "schema_version": 1, + "stage": "M14b_component_box_qualification", + "horizon": HORIZON, + "delta_hours": DELTA_HOURS, + "audit_tolerance": AUDIT_TOLERANCE, + "pair_absolute_tolerance": PAIR_ABSOLUTE_TOLERANCE, + "solver": "CLARABEL", + "solver_options": dict(CLARABEL_SOLVE_OPTIONS), + "canonicalization_backend": "SCIPY", + "cross_formulation_inference_permitted": False, + "pairs": pairs, + "decisions": decisions, + } diff --git a/experiments/m14_time_vectorization/run_m14b_component_bounds.py b/experiments/m14_time_vectorization/run_m14b_component_bounds.py new file mode 100644 index 0000000..877cb33 --- /dev/null +++ b/experiments/m14_time_vectorization/run_m14b_component_bounds.py @@ -0,0 +1,228 @@ +"""Run and retain the M14b formulation/component box qualification matrix.""" + +from __future__ import annotations + +import argparse +import hashlib +from importlib.metadata import PackageNotFoundError, version +import json +import os +from pathlib import Path +import platform +import subprocess +import sys +import tempfile +from typing import Any, cast + +from experiments.m14_time_vectorization.m14b_component_bounds import ( + AUDIT_TOLERANCE, + CLARABEL_SOLVE_OPTIONS, + DELTA_HOURS, + GATE_PAIRS, + HORIZON, + PAIR_ABSOLUTE_TOLERANCE, + BoundEncoding, + Formulation, + GateName, + compare_pair, + pair_decisions, + run_arm, +) + + +ROOT = Path(__file__).resolve().parents[2] +RESULT_PATH = ( + ROOT / "experiments/m14_time_vectorization/M14B_COMPONENT_BOX_RESULTS.json" +) + + +def _git(*arguments: str) -> str | None: + result = subprocess.run( + ["git", *arguments], + cwd=ROOT, + check=False, + capture_output=True, + text=True, + ) + return result.stdout.strip() if result.returncode == 0 else None + + +def _source_fingerprint() -> str: + paths = sorted((ROOT / "src/cvxopf").rglob("*.py")) + sorted( + (ROOT / "experiments/m14_time_vectorization").rglob("*.py") + ) + digest = hashlib.sha256() + for path in paths: + digest.update(path.relative_to(ROOT).as_posix().encode()) + digest.update(b"\0") + digest.update(path.read_bytes()) + digest.update(b"\0") + return digest.hexdigest() + + +def _package_version(name: str) -> str | None: + try: + return version(name) + except PackageNotFoundError: + return None + + +def execution_context() -> dict[str, Any]: + """Return source, machine, and solver provenance for one process.""" + return { + "git_commit": _git("rev-parse", "HEAD"), + "worktree_clean": _git("status", "--porcelain") == "", + "source_fingerprint": _source_fingerprint(), + "platform": platform.platform(), + "machine": platform.machine(), + "python": platform.python_version(), + "packages": { + name: _package_version(name) + for name in ("cvxpy", "clarabel", "numpy", "scipy") + }, + } + + +def _run_worker( + formulation: Formulation, + gate: GateName, + encoding: BoundEncoding, + output: Path, + expected_context: dict[str, Any], +) -> dict[str, Any]: + command = [ + sys.executable, + "-m", + "experiments.m14_time_vectorization.run_m14b_component_bounds", + "--worker", + "--formulation", + formulation, + "--gate", + gate, + "--encoding", + encoding, + "--output", + str(output), + ] + completed = subprocess.run( + command, + cwd=ROOT, + check=False, + capture_output=True, + text=True, + ) + if completed.returncode != 0: + raise RuntimeError( + f"M14b component-box worker failed for " + f"{formulation}/{gate}/{encoding}: {completed.stderr[-2000:]}" + ) + payload = cast(dict[str, Any], json.loads(output.read_text())) + context = cast(dict[str, Any], payload.pop("execution_context")) + for name in ("git_commit", "source_fingerprint"): + if context.get(name) != expected_context.get(name): + raise RuntimeError(f"M14b component-box worker {name} mismatch") + if context.get("worktree_clean") is not True: + raise RuntimeError("M14b component-box worker observed a dirty worktree") + return payload + + +def build_result() -> dict[str, Any]: + """Execute every arm in a fresh process under stable source provenance.""" + before = execution_context() + if before["worktree_clean"] is not True: + raise RuntimeError( + "authoritative M14b component-box execution requires a clean worktree" + ) + pairs = [] + decisions: dict[str, dict[str, Any]] = {} + with tempfile.TemporaryDirectory(prefix="cvxopf-m14b-box-") as temporary: + directory = Path(temporary) + for formulation, gate in GATE_PAIRS: + arms = { + encoding: _run_worker( + formulation, + gate, + encoding, + directory / f"{formulation}-{gate}-{encoding}.json", + before, + ) + for encoding in ("explicit", "leaf") + } + pair = compare_pair(arms["explicit"], arms["leaf"]) + pairs.append(pair) + for family, decision in pair_decisions(pair).items(): + decisions[f"{formulation}/{family}"] = decision + after = execution_context() + if ( + after["git_commit"] != before["git_commit"] + or after["source_fingerprint"] != before["source_fingerprint"] + ): + raise RuntimeError("M14b component-box execution source changed") + if after["worktree_clean"] is not True: + raise RuntimeError("M14b component-box worktree changed during execution") + return { + "schema_version": 1, + "stage": "M14b_component_box_qualification", + "horizon": HORIZON, + "delta_hours": DELTA_HOURS, + "audit_tolerance": AUDIT_TOLERANCE, + "pair_absolute_tolerance": PAIR_ABSOLUTE_TOLERANCE, + "solver": "CLARABEL", + "solver_options": dict(CLARABEL_SOLVE_OPTIONS), + "canonicalization_backend": "SCIPY", + "fresh_process_per_arm": True, + "cross_formulation_inference_permitted": False, + "pairs": pairs, + "decisions": decisions, + "execution_context": after, + } + + +def write_immutable(path: Path, value: object) -> None: + """Publish one JSON result without permitting replacement.""" + data = ( + json.dumps(value, sort_keys=True, indent=2, allow_nan=False) + "\n" + ).encode() + path.parent.mkdir(parents=True, exist_ok=True) + descriptor = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o644) + with os.fdopen(descriptor, "wb") as stream: + stream.write(data) + stream.flush() + os.fsync(stream.fileno()) + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--output", type=Path, default=RESULT_PATH) + parser.add_argument("--worker", action="store_true") + parser.add_argument("--formulation", choices=("lossy_dc", "singlenode_dc")) + parser.add_argument( + "--gate", + choices=("storage", "nondispatchable", "load_shedding", "hvdc"), + ) + parser.add_argument("--encoding", choices=("explicit", "leaf")) + arguments = parser.parse_args() + if arguments.worker: + if ( + arguments.formulation is None + or arguments.gate is None + or arguments.encoding is None + ): + parser.error("worker mode requires formulation, gate, and encoding") + result = run_arm( + arguments.formulation, + arguments.gate, + arguments.encoding, + ) + write_immutable( + arguments.output.resolve(), + {**result, "execution_context": execution_context()}, + ) + return + result = build_result() + write_immutable(arguments.output.resolve(), result) + print(json.dumps(result["decisions"], sort_keys=True, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/plans/milestone-14-time-vectorization.md b/plans/milestone-14-time-vectorization.md index 736de79..4c615ab 100644 --- a/plans/milestone-14-time-vectorization.md +++ b/plans/milestone-14-time-vectorization.md @@ -6,7 +6,9 @@ legacy Case9 and Case118 scaling ladders completed, and the formulation- specific leaf-bound gate passed. The typed horizon, one-call assembly, aggregation/publication, and public-result projection slices are implemented; -focused component-box qualification is next. +the reusable seven-gate component-box harness and fresh-process runner are also +implemented. A clean authoritative component-box execution and promotion +remain before the M14c handoff. The M14a baseline is bound to: - execution commit `1dd5e36dcae5ad9c8176b1d1202f1055acf95c03`; diff --git a/tests/test_m14b_component_bounds.py b/tests/test_m14b_component_bounds.py new file mode 100644 index 0000000..8c1266b --- /dev/null +++ b/tests/test_m14b_component_bounds.py @@ -0,0 +1,277 @@ +"""Focused gates for the final M14b component-box qualification slice.""" + +from pathlib import Path + +import numpy as np +import pytest + +from experiments.m14_time_vectorization.m14b_component_bounds import ( + AUDIT_TOLERANCE, + CandidateBox, + ComponentProbeBuild, + GATE_PAIRS, + HORIZON, + PAIR_ABSOLUTE_TOLERANCE, + _binding_probe, + build_probe, + compare_pair, + pair_decisions, + run_all, + run_arm, +) +from experiments.m14_time_vectorization.run_m14b_component_bounds import ( + build_result, + write_immutable, +) + + +@pytest.mark.parametrize(("formulation", "gate"), GATE_PAIRS) +def test_shared_harness_uses_identical_fixture_solver_and_backend(formulation, gate): + explicit = run_arm(formulation, gate, "explicit") + leaf = run_arm(formulation, gate, "leaf") + pair = compare_pair(explicit, leaf) + + assert explicit["fixture_sha256"] == leaf["fixture_sha256"] + assert explicit["solver"] == leaf["solver"] == "CLARABEL" + assert explicit["canonical_structure"]["backend"] == "SCIPY" + assert leaf["canonical_structure"]["backend"] == "SCIPY" + assert explicit["classification"] == leaf["classification"] == "accepted" + for arm in (explicit, leaf): + assert arm["source_structure"]["problem_is_dcp"] is True + assert arm["source_structure"]["objective_is_dcp"] is True + assert arm["source_structure"]["all_constraints_dcp"] is True + assert {"objective_reconstruction_abs", "p_net_reconstruction_abs"} <= set( + arm["residuals"] + ) + assert {"Pg", "p_net"} <= set(explicit["public_results"]) + assert ("p_flows" in explicit["public_results"]) is (formulation == "lossy_dc") + assert max(explicit["residuals"].values()) <= AUDIT_TOLERANCE + assert max(leaf["residuals"].values()) <= AUDIT_TOLERANCE + assert ( + explicit["source_structure"]["explicit_inequality_objects"] + > leaf["source_structure"]["explicit_inequality_objects"] + ) + assert pair["fixture_fingerprints_match"] is True + assert pair["both_accepted"] is True + assert pair["result_schemas_match"] is True + assert pair["cost_schemas_match"] is True + assert pair["probe_only_objective_term_schemas_match"] is True + assert pair["binding_probes_passed"] is True + assert pair["objective_absolute_residual"] <= PAIR_ABSOLUTE_TOLERANCE + assert pair["equivalent"] is True + + +@pytest.mark.parametrize(("formulation", "gate"), GATE_PAIRS) +def test_binding_probes_reach_every_declared_face(formulation, gate): + for encoding in ("explicit", "leaf"): + arm = run_arm(formulation, gate, encoding) + for probe in arm["binding_probes"]: + assert probe["accepted"] is True + assert probe["maximum_face_residual"] <= AUDIT_TOLERANCE + assert ( + probe["lower_face_coordinates"] + + probe["upper_face_coordinates"] + + probe["fixed_coordinates"] + > 0 + ) + + +@pytest.mark.parametrize("formulation", ("lossy_dc", "singlenode_dc")) +def test_storage_gate_covers_recurrence_faces_and_three_terminal_policies( + formulation, +): + build = build_probe(formulation, "storage", "leaf") + arm = run_arm(formulation, "storage", "leaf") + + assert [box.family for box in build.candidate_boxes] == [ + "storage_real_power", + "storage_soc", + ] + assert build.variables["b"].shape == (3, HORIZON) + assert build.variables["soc"].shape == (3, HORIZON + 1) + assert arm["device_ids"] == ["equality", "shortfall", "soft"] + assert arm["public_results"]["soc"] and len(arm["public_results"]["soc"]) == HORIZON + assert len(arm["public_results"]["storage_terminal_deviation"]) == 3 + assert set(arm["component_costs"]) == { + "storage_cost", + "storage_terminal_cost", + } + assert set(arm["residuals"]) >= { + "storage_initial_abs", + "storage_recurrence_abs", + "equality_terminal_abs", + "shortfall_terminal_abs", + "storage_terminal_cost_abs", + } + + +@pytest.mark.parametrize("formulation", ("lossy_dc", "singlenode_dc")) +def test_nondispatchable_gate_covers_zero_availability_and_rating_limits( + formulation, +): + build = build_probe(formulation, "nondispatchable", "leaf") + upper = build.candidate_boxes[0].upper + availability = np.asarray(build.inputs["availability"], dtype=float) + rating = np.asarray(build.inputs["rating"], dtype=float)[:, None] + arm = run_arm(formulation, "nondispatchable", "leaf") + + assert np.count_nonzero(upper == 0.0) > 0 + assert np.count_nonzero(availability < rating) > 0 + assert np.count_nonzero(availability > rating) > 0 + assert arm["public_results"]["curtailment"] + assert arm["component_costs"] == {} + assert set(arm["probe_only_objective_terms"]) == { + "nondispatchable_preference_probe_only" + } + assert set(arm["residuals"]) >= { + "availability_abs", + "rating_abs", + "curtailment_nonnegative_abs", + "nondispatchable_preference_probe_only_abs", + } + + +@pytest.mark.parametrize("formulation", ("lossy_dc", "singlenode_dc")) +def test_load_gate_covers_ineligible_width_served_load_and_cost(formulation): + build = build_probe(formulation, "load_shedding", "leaf") + arm = run_arm(formulation, "load_shedding", "leaf") + + assert np.count_nonzero(build.candidate_boxes[0].upper == 0.0) > 0 + assert arm["public_results"]["p_load"] + assert arm["public_results"]["q_load"] + assert arm["public_results"]["p_load_shed"] + assert arm["public_results"]["p_load_shed_total"] + assert arm["public_results"]["p_load_served"] + assert arm["public_results"]["energy_not_served_by_load"] + assert arm["public_results"]["energy_not_served"] >= 0.0 + assert set(arm["component_costs"]) == {"load_shedding_cost"} + assert set(arm["residuals"]) >= { + "eligibility_abs", + "ineligible_fraction_abs", + "q_load_reconstruction_abs", + "served_reconstruction_abs", + "shed_total_reconstruction_abs", + "energy_not_served_by_load_abs", + "energy_not_served_abs", + "shedding_cost_abs", + } + + +def test_hvdc_gate_covers_every_frozen_direction_and_loss_branch(): + build = build_probe("lossy_dc", "hvdc", "leaf") + arm = run_arm("lossy_dc", "hvdc", "leaf") + + assert np.asarray(build.inputs["direction"], dtype=object).tolist() == [ + "positive", + "negative", + "straddling", + "positive", + "positive", + ] + assert ( + np.count_nonzero( + build.candidate_boxes[0].lower == build.candidate_boxes[0].upper + ) + == HORIZON + ) + assert arm["public_results"]["p_hvdc_in"] + assert arm["public_results"]["p_hvdc_out"] + assert arm["public_results"]["hvdc_loss"] + assert set(arm["residuals"]) >= { + "hvdc_coupling_abs", + "hvdc_loss_abs", + "hvdc_loss_nonnegative_abs", + "hvdc_cost_abs", + } + + +def test_consolidated_matrix_emits_nine_local_decisions_without_cross_inference(): + result = run_all() + + assert result["cross_formulation_inference_permitted"] is False + assert len(result["pairs"]) == 7 + assert len(result["decisions"]) == 9 + assert all(pair["equivalent"] for pair in result["pairs"]) + assert all( + decision + == { + "leaf_bounds_qualified": True, + "selected_representation": "leaf", + "reason": "paired model and binding probe passed", + } + for decision in result["decisions"].values() + ) + + +def test_failed_pair_selects_explicit_without_blocking_other_gates(): + explicit = run_arm("lossy_dc", "nondispatchable", "explicit") + leaf = run_arm("lossy_dc", "nondispatchable", "leaf") + leaf["accepted"] = False + leaf["classification"] = "unusable_primal" + pair = compare_pair(explicit, leaf) + + assert pair["equivalent"] is False + assert pair_decisions(pair) == { + "nondispatchable_real_power": { + "leaf_bounds_qualified": False, + "selected_representation": "explicit", + "reason": "paired gate regressed; retain explicit inequalities", + } + } + + +def test_real_leaf_solver_exception_is_retained_and_selects_explicit(monkeypatch): + original_solve = ComponentProbeBuild.solve + + def fail_leaf(build: ComponentProbeBuild) -> None: + if build.encoding == "leaf": + raise RuntimeError("synthetic solver failure") + original_solve(build) + + monkeypatch.setattr(ComponentProbeBuild, "solve", fail_leaf) + explicit = run_arm("lossy_dc", "nondispatchable", "explicit") + leaf = run_arm("lossy_dc", "nondispatchable", "leaf") + pair = compare_pair(explicit, leaf) + + assert explicit["classification"] == "accepted" + assert leaf["classification"] == "solver_failure" + assert leaf["exception"] == "RuntimeError: synthetic solver failure" + assert leaf["solver"] is None + assert leaf["solver_iterations"] is None + assert leaf["solve_time"] is None + assert pair_decisions(pair)["nondispatchable_real_power"] == { + "leaf_bounds_qualified": False, + "selected_representation": "explicit", + "reason": "paired gate regressed; retain explicit inequalities", + } + + +def test_binding_probe_retains_solver_exception_without_statistics(monkeypatch): + def fail_solve(*_args, **_kwargs): + raise RuntimeError("synthetic binding failure") + + monkeypatch.setattr("cvxpy.Problem.solve", fail_solve) + probe = _binding_probe( + CandidateBox("x", "test_box", np.array([0.0]), np.array([1.0])), + "leaf", + ) + + assert probe["accepted"] is False + assert probe["exception"] == "RuntimeError: synthetic binding failure" + assert probe["solver"] is None + + +def test_authoritative_runner_rejects_dirty_tree_and_result_is_immutable( + monkeypatch, tmp_path: Path +): + monkeypatch.setattr( + "experiments.m14_time_vectorization.run_m14b_component_bounds.execution_context", + lambda: {"worktree_clean": False}, + ) + with pytest.raises(RuntimeError, match="clean worktree"): + build_result() + + path = tmp_path / "result.json" + write_immutable(path, {"value": 1}) + with pytest.raises(FileExistsError): + write_immutable(path, {"value": 2}) From 252b8c8d0cf243c4661c7aa0700f28f039afb8d2 Mon Sep 17 00:00:00 2001 From: Bennet Meyers Date: Fri, 28 Aug 2026 11:36:27 -0700 Subject: [PATCH 25/28] results(m14b): record component-bound qualification Promote the authoritative SCIPY/CLARABEL comparison and bind its execution commit and artifact hash. Record all nine tested lossy-DC and single-node component-box decisions as leaf-qualified, close the M14b gate, and hand the frozen assembly contract to M14c without extending the result to AC or making runtime/RSS claims. --- .../M14B_COMPONENT_BOX_RESULTS.json | 3978 +++++++++++++++++ 1 file changed, 3978 insertions(+) create mode 100644 experiments/m14_time_vectorization/M14B_COMPONENT_BOX_RESULTS.json diff --git a/experiments/m14_time_vectorization/M14B_COMPONENT_BOX_RESULTS.json b/experiments/m14_time_vectorization/M14B_COMPONENT_BOX_RESULTS.json new file mode 100644 index 0000000..04d8935 --- /dev/null +++ b/experiments/m14_time_vectorization/M14B_COMPONENT_BOX_RESULTS.json @@ -0,0 +1,3978 @@ +{ + "audit_tolerance": 2e-06, + "canonicalization_backend": "SCIPY", + "cross_formulation_inference_permitted": false, + "decisions": { + "lossy_dc/hvdc_input_power": { + "leaf_bounds_qualified": true, + "reason": "paired model and binding probe passed", + "selected_representation": "leaf" + }, + "lossy_dc/load_shed_fraction": { + "leaf_bounds_qualified": true, + "reason": "paired model and binding probe passed", + "selected_representation": "leaf" + }, + "lossy_dc/nondispatchable_real_power": { + "leaf_bounds_qualified": true, + "reason": "paired model and binding probe passed", + "selected_representation": "leaf" + }, + "lossy_dc/storage_real_power": { + "leaf_bounds_qualified": true, + "reason": "paired model and binding probe passed", + "selected_representation": "leaf" + }, + "lossy_dc/storage_soc": { + "leaf_bounds_qualified": true, + "reason": "paired model and binding probe passed", + "selected_representation": "leaf" + }, + "singlenode_dc/load_shed_fraction": { + "leaf_bounds_qualified": true, + "reason": "paired model and binding probe passed", + "selected_representation": "leaf" + }, + "singlenode_dc/nondispatchable_real_power": { + "leaf_bounds_qualified": true, + "reason": "paired model and binding probe passed", + "selected_representation": "leaf" + }, + "singlenode_dc/storage_real_power": { + "leaf_bounds_qualified": true, + "reason": "paired model and binding probe passed", + "selected_representation": "leaf" + }, + "singlenode_dc/storage_soc": { + "leaf_bounds_qualified": true, + "reason": "paired model and binding probe passed", + "selected_representation": "leaf" + } + }, + "delta_hours": 1.0, + "execution_context": { + "git_commit": "028b46e2f0af16fbff90a9bc991770f0267280a5", + "machine": "arm64", + "packages": { + "clarabel": "0.11.1", + "cvxpy": "1.9.2", + "numpy": "2.4.6", + "scipy": "1.17.1" + }, + "platform": "macOS-26.5.2-arm64-arm-64bit", + "python": "3.11.15", + "source_fingerprint": "45e2e91e95594b3418065c256ef476c70d14f7f679d1606a71f2fc34c57ac03b", + "worktree_clean": true + }, + "fresh_process_per_arm": true, + "horizon": 4, + "pair_absolute_tolerance": 2e-05, + "pairs": [ + { + "binding_probe_absolute_residuals": { + "storage_real_power": 4.440892098500626e-16, + "storage_soc": 5.329070518200751e-15 + }, + "binding_probes_passed": true, + "both_accepted": true, + "box_families": [ + "storage_real_power", + "storage_soc" + ], + "component_cost_absolute_residuals": { + "storage_cost": 5.551115123125783e-17, + "storage_terminal_cost": 0.0 + }, + "cost_schemas_match": true, + "equivalent": true, + "explicit": { + "accepted": true, + "binding_probes": [ + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "family": "storage_real_power", + "fixed_coordinates": 0, + "lower_face_coordinates": 6, + "maximum_face_residual": 8.207168278318022e-11, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 6, + "values": [ + [ + -3.999999999985989, + 3.999999999985989, + -3.999999999985989, + 3.999999999985989 + ], + [ + 2.9999999999179283, + -2.9999999999179283, + 2.9999999999179283, + -2.9999999999179283 + ], + [ + -4.999999999994094, + 4.999999999994094, + -4.999999999994094, + 4.999999999994094 + ] + ], + "variable": "b" + }, + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "family": "storage_soc", + "fixed_coordinates": 0, + "lower_face_coordinates": 8, + "maximum_face_residual": 8.204132140354549e-11, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 7, + "values": [ + [ + 2.3013027076165653e-11, + 9.999999999976989, + 2.3013027076165653e-11, + 9.999999999976989, + 2.3013027076165653e-11 + ], + [ + 7.99999999991796, + 8.204132140354549e-11, + 7.99999999991796, + 8.204132140354549e-11, + 7.99999999991796 + ], + [ + 1.0838593397325766e-11, + 11.99999999998916, + 1.0838593397325766e-11, + 11.99999999998916, + 1.0838593397325766e-11 + ] + ], + "variable": "soc" + } + ], + "canonical_structure": { + "backend": "SCIPY", + "canonical_variables": 64, + "coefficient_columns": 64, + "coefficient_nonzeros": 221, + "coefficient_rows": 140, + "equality_rows": 37, + "nonnegative_rows": 103, + "quadratic_nonzeros": 25, + "reductions": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "soc_dimensions": [] + }, + "classification": "accepted", + "component_costs": { + "storage_cost": 0.27186839813739494, + "storage_terminal_cost": 0.060819355557017854 + }, + "device_ids": [ + "equality", + "shortfall", + "soft" + ], + "encoding": "explicit", + "exception": null, + "fixture_sha256": "7420e91595b5546801ea3371c245a71db19e7de9b2ab96b28c5803ab9233ebc5", + "formulation": "lossy_dc", + "gate": "storage", + "objective": 9.2377274500941, + "probe_only_objective_terms": {}, + "process_peak_rss_bytes": { + "after_canonicalization": 112033792, + "after_construction": 110755840, + "after_solve": 112574464 + }, + "public_results": { + "Pg": [ + [ + 4.658070171859221, + 4.58793587709721 + ], + [ + 7.137417462965083, + 6.944729880049209 + ], + [ + 7.976511848305223, + 8.025618079042774 + ], + [ + 9.011494621943095, + 8.91438497413565 + ] + ], + "b": [ + [ + 1.93924393291133, + 1.0817587175238104, + 1.732991300608427 + ], + [ + -1.9911691212657543, + 1.1288945975831806, + 0.780127180668283 + ], + [ + 1.0056127664411099, + -0.8294876384366529, + -1.1782550553524525 + ], + [ + -0.9536875780866854, + -0.8117123005342471, + -0.1604797174578147 + ] + ], + "p_flows": [ + [ + -1.4026858952294488 + ], + [ + -3.853751658300673 + ], + [ + 0.9821246147463337 + ], + [ + -1.9421929561435889 + ] + ], + "p_net": [ + [ + -1.4026858952294496, + 1.402685895229447 + ], + [ + -3.853751658300671, + 3.8537516583006735 + ], + [ + 0.9821246147463327, + -0.982124614746331 + ], + [ + -1.9421929561435896, + 1.9421929561435887 + ] + ], + "soc": [ + [ + 3.0607560670886698, + 2.9182412824761825, + 4.267008699391574 + ], + [ + 5.051925188354424, + 1.789346684892998, + 3.486881518723291 + ], + [ + 4.046312421913314, + 2.6188343233296454, + 4.665136574075744 + ], + [ + 5.0, + 3.43054662386389, + 4.825616291533558 + ] + ], + "storage_injection": [ + [ + 1.93924393291133, + 2.814750018132237 + ], + [ + -1.9911691212657543, + 1.9090217782514636 + ], + [ + 1.0056127664411099, + -2.007742693789105 + ], + [ + -0.9536875780866854, + -0.9721920179920618 + ] + ], + "storage_terminal_deviation": [ + 0.0, + 0.43054662386389, + -0.1743837084664417 + ] + }, + "residuals": { + "active_balance_abs": 2.7755575615628914e-15, + "component_injection_abs": 0.0, + "equality_terminal_abs": 0.0, + "objective_reconstruction_abs": 0.0, + "p_net_reconstruction_abs": 0.0, + "shortfall_terminal_abs": 0.0, + "storage_cost_abs": 0.0, + "storage_initial_abs": 3.552713678800501e-15, + "storage_real_power_box_abs": 0.0, + "storage_recurrence_abs": 5.440092820663267e-15, + "storage_soc_box_abs": 0.0, + "storage_terminal_cost_abs": 0.0 + }, + "solve_time": 0.000226834, + "solver": "CLARABEL", + "solver_iterations": 8, + "source_structure": { + "all_constraints_dcp": true, + "constraint_objects": 14, + "equality_objects": 5, + "explicit_inequality_objects": 9, + "explicit_scalar_inequalities": 79, + "objective_is_dcp": true, + "problem_is_dcp": true, + "scalar_equalities": 24, + "scalar_variables": 39, + "variable_objects": 4, + "variable_shapes": { + "Pg": [ + 2, + 4 + ], + "b": [ + 3, + 4 + ], + "p_flows": [ + 1, + 4 + ], + "soc": [ + 3, + 5 + ] + } + }, + "status": "optimal", + "timing_seconds": { + "canonicalization": 0.009071624954231083, + "construction": 0.001818374963477254, + "solve": 0.0009357499657198787 + } + }, + "fixture_fingerprints_match": true, + "fixture_sha256": "7420e91595b5546801ea3371c245a71db19e7de9b2ab96b28c5803ab9233ebc5", + "formulation": "lossy_dc", + "gate": "storage", + "leaf": { + "accepted": true, + "binding_probes": [ + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "family": "storage_real_power", + "fixed_coordinates": 0, + "lower_face_coordinates": 6, + "maximum_face_residual": 8.207212687239007e-11, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 6, + "values": [ + [ + -3.9999999999859885, + 3.9999999999859885, + -3.9999999999859885, + 3.9999999999859885 + ], + [ + 2.999999999917928, + -2.999999999917928, + 2.999999999917928, + -2.999999999917928 + ], + [ + -4.999999999994094, + 4.999999999994094, + -4.999999999994094, + 4.999999999994094 + ] + ], + "variable": "b" + }, + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "family": "storage_soc", + "fixed_coordinates": 0, + "lower_face_coordinates": 8, + "maximum_face_residual": 8.204199473697239e-11, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 7, + "values": [ + [ + 2.3013256149782365e-11, + 9.999999999976984, + 2.3013256149782365e-11, + 9.999999999976984, + 2.3013256149782365e-11 + ], + [ + 7.999999999917958, + 8.204199473697239e-11, + 7.999999999917958, + 8.204199473697239e-11, + 7.999999999917958 + ], + [ + 1.0838730844929666e-11, + 11.99999999998916, + 1.0838730844929666e-11, + 11.99999999998916, + 1.0838730844929666e-11 + ] + ], + "variable": "soc" + } + ], + "canonical_structure": { + "backend": "SCIPY", + "canonical_variables": 64, + "coefficient_columns": 64, + "coefficient_nonzeros": 221, + "coefficient_rows": 140, + "equality_rows": 37, + "nonnegative_rows": 103, + "quadratic_nonzeros": 25, + "reductions": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "soc_dimensions": [] + }, + "classification": "accepted", + "component_costs": { + "storage_cost": 0.271868398137395, + "storage_terminal_cost": 0.060819355557017854 + }, + "device_ids": [ + "equality", + "shortfall", + "soft" + ], + "encoding": "leaf", + "exception": null, + "fixture_sha256": "7420e91595b5546801ea3371c245a71db19e7de9b2ab96b28c5803ab9233ebc5", + "formulation": "lossy_dc", + "gate": "storage", + "objective": 9.2377274500941, + "probe_only_objective_terms": {}, + "process_peak_rss_bytes": { + "after_canonicalization": 112197632, + "after_construction": 110854144, + "after_solve": 112754688 + }, + "public_results": { + "Pg": [ + [ + 4.6580701718592215, + 4.587935877097211 + ], + [ + 7.137417462965082, + 6.944729880049209 + ], + [ + 7.976511848305221, + 8.025618079042776 + ], + [ + 9.011494621943097, + 8.914384974135652 + ] + ], + "b": [ + [ + 1.9392439329113298, + 1.0817587175238104, + 1.7329913006084272 + ], + [ + -1.9911691212657543, + 1.1288945975831806, + 0.7801271806682832 + ], + [ + 1.0056127664411096, + -0.829487638436653, + -1.1782550553524525 + ], + [ + -0.9536875780866856, + -0.8117123005342471, + -0.16047971745781464 + ] + ], + "p_flows": [ + [ + -1.4026858952294476 + ], + [ + -3.853751658300672 + ], + [ + 0.982124614746331 + ], + [ + -1.942192956143589 + ] + ], + "p_net": [ + [ + -1.4026858952294488, + 1.4026858952294479 + ], + [ + -3.8537516583006717, + 3.8537516583006735 + ], + [ + 0.982124614746331, + -0.9821246147463301 + ], + [ + -1.9421929561435896, + 1.9421929561435904 + ] + ], + "soc": [ + [ + 3.0607560670886698, + 2.9182412824761825, + 4.267008699391574 + ], + [ + 5.051925188354423, + 1.7893466848929973, + 3.486881518723291 + ], + [ + 4.046312421913314, + 2.618834323329645, + 4.665136574075744 + ], + [ + 5.0, + 3.4305466238638895, + 4.825616291533558 + ] + ], + "storage_injection": [ + [ + 1.9392439329113298, + 2.8147500181322376 + ], + [ + -1.9911691212657543, + 1.9090217782514638 + ], + [ + 1.0056127664411096, + -2.0077426937891056 + ], + [ + -0.9536875780866856, + -0.9721920179920618 + ] + ], + "storage_terminal_deviation": [ + 0.0, + 0.43054662386388953, + -0.1743837084664417 + ] + }, + "residuals": { + "active_balance_abs": 1.3322676295501878e-15, + "component_injection_abs": 0.0, + "equality_terminal_abs": 0.0, + "objective_reconstruction_abs": 0.0, + "p_net_reconstruction_abs": 0.0, + "shortfall_terminal_abs": 0.0, + "storage_cost_abs": 0.0, + "storage_initial_abs": 3.9968028886505635e-15, + "storage_real_power_box_abs": 0.0, + "storage_recurrence_abs": 5.329070518200751e-15, + "storage_soc_box_abs": 0.0, + "storage_terminal_cost_abs": 0.0 + }, + "solve_time": 0.000245126, + "solver": "CLARABEL", + "solver_iterations": 8, + "source_structure": { + "all_constraints_dcp": true, + "constraint_objects": 10, + "equality_objects": 5, + "explicit_inequality_objects": 5, + "explicit_scalar_inequalities": 25, + "objective_is_dcp": true, + "problem_is_dcp": true, + "scalar_equalities": 24, + "scalar_variables": 39, + "variable_objects": 4, + "variable_shapes": { + "Pg": [ + 2, + 4 + ], + "b": [ + 3, + 4 + ], + "p_flows": [ + 1, + 4 + ], + "soc": [ + 3, + 5 + ] + } + }, + "status": "optimal", + "timing_seconds": { + "canonicalization": 0.010134708019904792, + "construction": 0.0022428749362006783, + "solve": 0.0009674580069258809 + } + }, + "objective_absolute_residual": 0.0, + "probe_only_objective_term_absolute_residuals": {}, + "probe_only_objective_term_schemas_match": true, + "public_result_absolute_residuals": { + "Pg": 1.7763568394002505e-15, + "b": 2.220446049250313e-16, + "p_flows": 2.7755575615628914e-15, + "p_net": 1.7763568394002505e-15, + "soc": 8.881784197001252e-16, + "storage_injection": 4.440892098500626e-16, + "storage_terminal_deviation": 4.440892098500626e-16 + }, + "result_schemas_match": true + }, + { + "binding_probe_absolute_residuals": { + "storage_real_power": 4.440892098500626e-16, + "storage_soc": 5.329070518200751e-15 + }, + "binding_probes_passed": true, + "both_accepted": true, + "box_families": [ + "storage_real_power", + "storage_soc" + ], + "component_cost_absolute_residuals": { + "storage_cost": 0.0, + "storage_terminal_cost": 0.0 + }, + "cost_schemas_match": true, + "equivalent": true, + "explicit": { + "accepted": true, + "binding_probes": [ + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "family": "storage_real_power", + "fixed_coordinates": 0, + "lower_face_coordinates": 6, + "maximum_face_residual": 8.207168278318022e-11, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 6, + "values": [ + [ + -3.999999999985989, + 3.999999999985989, + -3.999999999985989, + 3.999999999985989 + ], + [ + 2.9999999999179283, + -2.9999999999179283, + 2.9999999999179283, + -2.9999999999179283 + ], + [ + -4.999999999994094, + 4.999999999994094, + -4.999999999994094, + 4.999999999994094 + ] + ], + "variable": "b" + }, + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "family": "storage_soc", + "fixed_coordinates": 0, + "lower_face_coordinates": 8, + "maximum_face_residual": 8.204132140354549e-11, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 7, + "values": [ + [ + 2.3013027076165653e-11, + 9.999999999976989, + 2.3013027076165653e-11, + 9.999999999976989, + 2.3013027076165653e-11 + ], + [ + 7.99999999991796, + 8.204132140354549e-11, + 7.99999999991796, + 8.204132140354549e-11, + 7.99999999991796 + ], + [ + 1.0838593397325766e-11, + 11.99999999998916, + 1.0838593397325766e-11, + 11.99999999998916, + 1.0838593397325766e-11 + ] + ], + "variable": "soc" + } + ], + "canonical_structure": { + "backend": "SCIPY", + "canonical_variables": 56, + "coefficient_columns": 56, + "coefficient_nonzeros": 193, + "coefficient_rows": 120, + "equality_rows": 33, + "nonnegative_rows": 87, + "quadratic_nonzeros": 17, + "reductions": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "soc_dimensions": [] + }, + "classification": "accepted", + "component_costs": { + "storage_cost": 0.26673207547802114, + "storage_terminal_cost": 0.11257565110954426 + }, + "device_ids": [ + "equality", + "shortfall", + "soft" + ], + "encoding": "explicit", + "exception": null, + "fixture_sha256": "ce0b74c522820db42ef1f4ceb1aa7b2da0bf4b832e192ce1ce403c1db1a62e2e", + "formulation": "singlenode_dc", + "gate": "storage", + "objective": 17.730304919332514, + "probe_only_objective_terms": {}, + "process_peak_rss_bytes": { + "after_canonicalization": 112672768, + "after_construction": 111394816, + "after_solve": 113197056 + }, + "public_results": { + "Pg": [ + [ + 9.266159072925888 + ], + [ + 13.964272280365552 + ], + [ + 15.832196808669465 + ], + [ + 17.70012133735331 + ] + ], + "b": [ + [ + 1.8915094339374516, + 1.1415094204787752, + 1.7008220726579102 + ], + [ + -1.9945283018762696, + 1.2354716846578013, + 0.7947843368529379 + ], + [ + 1.0228301887085944, + -0.7071698247423545, + -1.1478571726356774 + ], + [ + -0.9198113207699321, + -0.6698113340905466, + -0.11049868249280301 + ] + ], + "p_net": [ + 2.4868995751603507e-14, + 2.1316282072803006e-14, + 2.842170943040401e-14, + 2.842170943040401e-14 + ], + "soc": [ + [ + 3.108490566062494, + 2.8584905795185134, + 4.299177927342059 + ], + [ + 5.103018867938731, + 1.6230188948593542, + 3.504393590489113 + ], + [ + 4.080188679230119, + 2.3301887196004114, + 4.652250763124775 + ], + [ + 5.000000000000025, + 3.000000053689596, + 4.762749445617566 + ] + ], + "storage_injection": [ + [ + 1.8915094339374516, + 2.8423314931366854 + ], + [ + -1.9945283018762696, + 2.0302560215107395 + ], + [ + 1.0228301887085944, + -1.8550269973780318 + ], + [ + -0.9198113207699321, + -0.7803100165833496 + ] + ], + "storage_terminal_deviation": [ + 2.4868995751603507e-14, + 5.368959588025746e-08, + -0.2372505543824337 + ] + }, + "residuals": { + "active_balance_abs": 2.842170943040401e-14, + "component_injection_abs": 0.0, + "equality_terminal_abs": 2.4868995751603507e-14, + "objective_reconstruction_abs": 0.0, + "p_net_reconstruction_abs": 0.0, + "shortfall_terminal_abs": 0.0, + "storage_cost_abs": 0.0, + "storage_initial_abs": 1.3558043576722412e-12, + "storage_real_power_box_abs": 0.0, + "storage_recurrence_abs": 1.3621326289126046e-12, + "storage_soc_box_abs": 0.0, + "storage_terminal_cost_abs": 0.0 + }, + "solve_time": 0.000208459, + "solver": "CLARABEL", + "solver_iterations": 8, + "source_structure": { + "all_constraints_dcp": true, + "constraint_objects": 11, + "equality_objects": 4, + "explicit_inequality_objects": 7, + "explicit_scalar_inequalities": 63, + "objective_is_dcp": true, + "problem_is_dcp": true, + "scalar_equalities": 20, + "scalar_variables": 31, + "variable_objects": 3, + "variable_shapes": { + "Pg": [ + 1, + 4 + ], + "b": [ + 3, + 4 + ], + "soc": [ + 3, + 5 + ] + } + }, + "status": "optimal", + "timing_seconds": { + "canonicalization": 0.007917999988421798, + "construction": 0.0014709170209243894, + "solve": 0.0008925410220399499 + } + }, + "fixture_fingerprints_match": true, + "fixture_sha256": "ce0b74c522820db42ef1f4ceb1aa7b2da0bf4b832e192ce1ce403c1db1a62e2e", + "formulation": "singlenode_dc", + "gate": "storage", + "leaf": { + "accepted": true, + "binding_probes": [ + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "family": "storage_real_power", + "fixed_coordinates": 0, + "lower_face_coordinates": 6, + "maximum_face_residual": 8.207212687239007e-11, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 6, + "values": [ + [ + -3.9999999999859885, + 3.9999999999859885, + -3.9999999999859885, + 3.9999999999859885 + ], + [ + 2.999999999917928, + -2.999999999917928, + 2.999999999917928, + -2.999999999917928 + ], + [ + -4.999999999994094, + 4.999999999994094, + -4.999999999994094, + 4.999999999994094 + ] + ], + "variable": "b" + }, + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "family": "storage_soc", + "fixed_coordinates": 0, + "lower_face_coordinates": 8, + "maximum_face_residual": 8.204199473697239e-11, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 7, + "values": [ + [ + 2.3013256149782365e-11, + 9.999999999976984, + 2.3013256149782365e-11, + 9.999999999976984, + 2.3013256149782365e-11 + ], + [ + 7.999999999917958, + 8.204199473697239e-11, + 7.999999999917958, + 8.204199473697239e-11, + 7.999999999917958 + ], + [ + 1.0838730844929666e-11, + 11.99999999998916, + 1.0838730844929666e-11, + 11.99999999998916, + 1.0838730844929666e-11 + ] + ], + "variable": "soc" + } + ], + "canonical_structure": { + "backend": "SCIPY", + "canonical_variables": 56, + "coefficient_columns": 56, + "coefficient_nonzeros": 193, + "coefficient_rows": 120, + "equality_rows": 33, + "nonnegative_rows": 87, + "quadratic_nonzeros": 17, + "reductions": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "soc_dimensions": [] + }, + "classification": "accepted", + "component_costs": { + "storage_cost": 0.26673207547802114, + "storage_terminal_cost": 0.11257565110954426 + }, + "device_ids": [ + "equality", + "shortfall", + "soft" + ], + "encoding": "leaf", + "exception": null, + "fixture_sha256": "ce0b74c522820db42ef1f4ceb1aa7b2da0bf4b832e192ce1ce403c1db1a62e2e", + "formulation": "singlenode_dc", + "gate": "storage", + "objective": 17.730304919332518, + "probe_only_objective_terms": {}, + "process_peak_rss_bytes": { + "after_canonicalization": 113197056, + "after_construction": 111968256, + "after_solve": 113672192 + }, + "public_results": { + "Pg": [ + [ + 9.266159072925893 + ], + [ + 13.964272280365561 + ], + [ + 15.83219680866947 + ], + [ + 17.700121337353316 + ] + ], + "b": [ + [ + 1.8915094339374519, + 1.1415094204787681, + 1.7008220726579106 + ], + [ + -1.9945283018762694, + 1.2354716846577942, + 0.794784336852938 + ], + [ + 1.0228301887085947, + -0.7071698247423618, + -1.1478571726356774 + ], + [ + -0.9198113207699318, + -0.6698113340905537, + -0.11049868249280315 + ] + ], + "p_net": [ + 2.3092638912203256e-14, + 2.4868995751603507e-14, + 2.6645352591003757e-14, + 2.842170943040401e-14 + ], + "soc": [ + [ + 3.108490566062494, + 2.858490579518521, + 4.299177927342059 + ], + [ + 5.103018867938739, + 1.6230188948594133, + 3.5043935904891126 + ], + [ + 4.080188679230118, + 2.330188719600327, + 4.652250763124775 + ], + [ + 5.000000000000025, + 3.0000000536896243, + 4.762749445617566 + ] + ], + "storage_injection": [ + [ + 1.8915094339374519, + 2.8423314931366788 + ], + [ + -1.9945283018762694, + 2.0302560215107324 + ], + [ + 1.0228301887085947, + -1.8550269973780393 + ], + [ + -0.9198113207699318, + -0.7803100165833569 + ] + ], + "storage_terminal_deviation": [ + 2.4868995751603507e-14, + 5.368962430196689e-08, + -0.2372505543824337 + ] + }, + "residuals": { + "active_balance_abs": 2.842170943040401e-14, + "component_injection_abs": 0.0, + "equality_terminal_abs": 2.4868995751603507e-14, + "objective_reconstruction_abs": 0.0, + "p_net_reconstruction_abs": 0.0, + "shortfall_terminal_abs": 0.0, + "storage_cost_abs": 0.0, + "storage_initial_abs": 1.3558043576722412e-12, + "storage_real_power_box_abs": 0.0, + "storage_recurrence_abs": 1.4480638910185917e-12, + "storage_soc_box_abs": 0.0, + "storage_terminal_cost_abs": 0.0 + }, + "solve_time": 0.00019688, + "solver": "CLARABEL", + "solver_iterations": 8, + "source_structure": { + "all_constraints_dcp": true, + "constraint_objects": 7, + "equality_objects": 4, + "explicit_inequality_objects": 3, + "explicit_scalar_inequalities": 9, + "objective_is_dcp": true, + "problem_is_dcp": true, + "scalar_equalities": 20, + "scalar_variables": 31, + "variable_objects": 3, + "variable_shapes": { + "Pg": [ + 1, + 4 + ], + "b": [ + 3, + 4 + ], + "soc": [ + 3, + 5 + ] + } + }, + "status": "optimal", + "timing_seconds": { + "canonicalization": 0.008255832944996655, + "construction": 0.001508292043581605, + "solve": 0.0007170420140028 + } + }, + "objective_absolute_residual": 3.552713678800501e-15, + "probe_only_objective_term_absolute_residuals": {}, + "probe_only_objective_term_schemas_match": true, + "public_result_absolute_residuals": { + "Pg": 8.881784197001252e-15, + "b": 7.327471962526033e-15, + "p_net": 3.552713678800501e-15, + "soc": 8.43769498715119e-14, + "storage_injection": 7.549516567451064e-15, + "storage_terminal_deviation": 2.842170943040401e-14 + }, + "result_schemas_match": true + }, + { + "binding_probe_absolute_residuals": { + "nondispatchable_real_power": 5.399774218321567e-11 + }, + "binding_probes_passed": true, + "both_accepted": true, + "box_families": [ + "nondispatchable_real_power" + ], + "component_cost_absolute_residuals": {}, + "cost_schemas_match": true, + "equivalent": true, + "explicit": { + "accepted": true, + "binding_probes": [ + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "family": "nondispatchable_real_power", + "fixed_coordinates": 2, + "lower_face_coordinates": 4, + "maximum_face_residual": 2.373539495457986e-09, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 6, + "values": [ + [ + -3.3836502439235994e-11, + 1.9999999997217413, + -5.399774218321567e-11, + 0.9999999976264605 + ], + [ + 2.999999999972334, + 2.373539495457986e-09, + 2.999999999972334, + 2.766636656776906e-11 + ], + [ + 2.7825861960995294e-10, + 4.000000000053998, + -3.3836502439235994e-11, + 5.000000000034967 + ] + ], + "variable": "p_nd" + } + ], + "canonical_structure": { + "backend": "SCIPY", + "canonical_variables": 24, + "coefficient_columns": 24, + "coefficient_nonzeros": 88, + "coefficient_rows": 68, + "equality_rows": 8, + "nonnegative_rows": 60, + "quadratic_nonzeros": 24, + "reductions": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "soc_dimensions": [] + }, + "classification": "accepted", + "component_costs": {}, + "device_ids": [ + "solar-a", + "wind-b", + "solar-c" + ], + "encoding": "explicit", + "exception": null, + "fixture_sha256": "7e149d474078c3fa150196adab360df1550e5322bba7a42ca5ca47fb4ad94b7f", + "formulation": "lossy_dc", + "gate": "nondispatchable", + "objective": 31.09839024399847, + "probe_only_objective_terms": { + "nondispatchable_preference_probe_only": 21.09400000008698 + }, + "process_peak_rss_bytes": { + "after_canonicalization": 112394240, + "after_construction": 111280128, + "after_solve": 112951296 + }, + "public_results": { + "Pg": [ + [ + 8.585365853661184, + 8.41463414634459 + ], + [ + 7.585365853661524, + 7.41463414634521 + ], + [ + 7.975609756100979, + 8.024390243907346 + ], + [ + 7.634146341467224, + 7.365853658540992 + ] + ], + "curtailment": [ + [ + -1.2628921748057157e-15, + 2.0000000000027907, + 2.9880542484761463e-12 + ], + [ + 2.8896884884943574e-12, + 1.053490628066811e-12, + 2.7911006839076435e-12 + ], + [ + 2.0000000000024523, + 5.874412067896628e-12, + -8.026362482593246e-16 + ], + [ + 4.4919623576333834e-13, + 3.0000000000028155, + 4.952482868247898e-12 + ] + ], + "nondispatchable_injection": [ + [ + 1.2628921748057157e-15, + 4.9999999999942215 + ], + [ + 1.9999999999971103, + 4.999999999996155 + ], + [ + 3.9999999999975477, + 2.9999999999941265 + ], + [ + 0.9999999999995508, + 7.999999999992232 + ] + ], + "p_flows": [ + [ + -3.414634146338812 + ], + [ + -3.4146341463413648 + ], + [ + 0.9756097560985265 + ], + [ + -5.365853658533223 + ] + ], + "p_nd": [ + [ + 1.2628921748057157e-15, + 2.9999999999972093, + 1.999999999997012 + ], + [ + 1.9999999999971103, + 0.9999999999989465, + 3.999999999997209 + ], + [ + 3.9999999999975477, + 2.9999999999941256, + 8.026362482593246e-16 + ], + [ + 0.9999999999995508, + 2.9999999999971845, + 4.9999999999950475 + ] + ], + "p_net": [ + [ + -3.4146341463388143, + 3.414634146338811 + ], + [ + -3.414634146341365, + 3.414634146341365 + ], + [ + 0.9756097560985264, + -0.9756097560985282 + ], + [ + -5.365853658533226, + 5.365853658533224 + ] + ] + }, + "residuals": { + "active_balance_abs": 2.6645352591003757e-15, + "availability_abs": 1.2628921748057157e-15, + "component_injection_abs": 0.0, + "curtailment_abs": 0.0, + "curtailment_nonnegative_abs": 1.2628921748057157e-15, + "nondispatchable_preference_probe_only_abs": 0.0, + "nondispatchable_real_power_box_abs": 1.2628921748057157e-15, + "objective_reconstruction_abs": 0.0, + "p_net_reconstruction_abs": 0.0, + "rating_abs": 0.0 + }, + "solve_time": 0.000171585, + "solver": "CLARABEL", + "solver_iterations": 10, + "source_structure": { + "all_constraints_dcp": true, + "constraint_objects": 9, + "equality_objects": 2, + "explicit_inequality_objects": 7, + "explicit_scalar_inequalities": 60, + "objective_is_dcp": true, + "problem_is_dcp": true, + "scalar_equalities": 8, + "scalar_variables": 24, + "variable_objects": 3, + "variable_shapes": { + "Pg": [ + 2, + 4 + ], + "p_flows": [ + 1, + 4 + ], + "p_nd": [ + 3, + 4 + ] + } + }, + "status": "optimal", + "timing_seconds": { + "canonicalization": 0.006753791938535869, + "construction": 0.002051625051535666, + "solve": 0.000702582998201251 + } + }, + "fixture_fingerprints_match": true, + "fixture_sha256": "7e149d474078c3fa150196adab360df1550e5322bba7a42ca5ca47fb4ad94b7f", + "formulation": "lossy_dc", + "gate": "nondispatchable", + "leaf": { + "accepted": true, + "binding_probes": [ + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "family": "nondispatchable_real_power", + "fixed_coordinates": 2, + "lower_face_coordinates": 4, + "maximum_face_residual": 2.3735440869585647e-09, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 6, + "values": [ + [ + 0.0, + 1.9999999997217406, + 0.0, + 0.999999997626456 + ], + [ + 2.9999999999723332, + 2.3735440869585647e-09, + 2.9999999999723332, + 2.766653065476649e-11 + ], + [ + 2.782592566431233e-10, + 4.0, + 0.0, + 5.0 + ] + ], + "variable": "p_nd" + } + ], + "canonical_structure": { + "backend": "SCIPY", + "canonical_variables": 24, + "coefficient_columns": 24, + "coefficient_nonzeros": 76, + "coefficient_rows": 56, + "equality_rows": 8, + "nonnegative_rows": 48, + "quadratic_nonzeros": 24, + "reductions": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "soc_dimensions": [] + }, + "classification": "accepted", + "component_costs": {}, + "device_ids": [ + "solar-a", + "wind-b", + "solar-c" + ], + "encoding": "leaf", + "exception": null, + "fixture_sha256": "7e149d474078c3fa150196adab360df1550e5322bba7a42ca5ca47fb4ad94b7f", + "formulation": "lossy_dc", + "gate": "nondispatchable", + "objective": 31.09839025251219, + "probe_only_objective_terms": { + "nondispatchable_preference_probe_only": 21.094000007801228 + }, + "process_peak_rss_bytes": { + "after_canonicalization": 112066560, + "after_construction": 110952448, + "after_solve": 112607232 + }, + "public_results": { + "Pg": [ + [ + 8.585365853788277, + 8.41463414666083 + ], + [ + 7.585365853840819, + 7.414634146833889 + ], + [ + 7.975609756297657, + 8.024390244346685 + ], + [ + 7.634146341719182, + 7.365853659118404 + ] + ], + "curtailment": [ + [ + 0.0, + 2.0000000003194267, + 1.2971201890366046e-10 + ], + [ + 2.7729618601313177e-10, + 6.873013269625972e-11, + 3.2868197052948744e-10 + ], + [ + 2.0000000003232885, + 3.210538501718929e-10, + 0.0 + ], + [ + 2.2262491850000288e-10, + 3.000000000329883, + 2.850777391927295e-10 + ] + ], + "nondispatchable_injection": [ + [ + 0.0, + 4.9999999995508615 + ], + [ + 1.9999999997227038, + 4.999999999602588 + ], + [ + 3.9999999996767115, + 2.999999999678946 + ], + [ + 0.9999999997773751, + 7.9999999993850395 + ] + ], + "p_flows": [ + [ + -3.4146341462116916 + ], + [ + -3.414634146436477 + ], + [ + 0.9756097559743673 + ], + [ + -5.365853658503443 + ] + ], + "p_nd": [ + [ + 0.0, + 2.9999999996805733, + 1.999999999870288 + ], + [ + 1.9999999997227038, + 0.9999999999312699, + 3.999999999671318 + ], + [ + 3.9999999996767115, + 2.999999999678946, + 0.0 + ], + [ + 0.9999999997773751, + 2.999999999670117, + 4.999999999714922 + ] + ], + "p_net": [ + [ + -3.414634146211723, + 3.414634146211693 + ], + [ + -3.4146341464364767, + 3.4146341464364767 + ], + [ + 0.9756097559743679, + -0.9756097559743679 + ], + [ + -5.365853658503443, + 5.365853658503443 + ] + ] + }, + "residuals": { + "active_balance_abs": 3.1530333899354446e-14, + "availability_abs": 0.0, + "component_injection_abs": 0.0, + "curtailment_abs": 0.0, + "curtailment_nonnegative_abs": 0.0, + "nondispatchable_preference_probe_only_abs": 0.0, + "nondispatchable_real_power_box_abs": 0.0, + "objective_reconstruction_abs": 0.0, + "p_net_reconstruction_abs": 0.0, + "rating_abs": 0.0 + }, + "solve_time": 0.000121414, + "solver": "CLARABEL", + "solver_iterations": 9, + "source_structure": { + "all_constraints_dcp": true, + "constraint_objects": 6, + "equality_objects": 2, + "explicit_inequality_objects": 4, + "explicit_scalar_inequalities": 24, + "objective_is_dcp": true, + "problem_is_dcp": true, + "scalar_equalities": 8, + "scalar_variables": 24, + "variable_objects": 3, + "variable_shapes": { + "Pg": [ + 2, + 4 + ], + "p_flows": [ + 1, + 4 + ], + "p_nd": [ + 3, + 4 + ] + } + }, + "status": "optimal", + "timing_seconds": { + "canonicalization": 0.007378874928690493, + "construction": 0.0014292499981820583, + "solve": 0.0005940829869359732 + } + }, + "objective_absolute_residual": 8.513719507163842e-09, + "probe_only_objective_term_absolute_residuals": { + "nondispatchable_preference_probe_only": 7.714248795309686e-09 + }, + "probe_only_objective_term_schemas_match": true, + "public_result_absolute_residuals": { + "Pg": 5.77411896074409e-10, + "curtailment": 3.270672621624726e-10, + "nondispatchable_injection": 6.071925184869542e-10, + "p_flows": 1.2712053631958042e-10, + "p_nd": 3.270672621624726e-10, + "p_net": 1.2711787178432132e-10 + }, + "result_schemas_match": true + }, + { + "binding_probe_absolute_residuals": { + "nondispatchable_real_power": 5.399774218321567e-11 + }, + "binding_probes_passed": true, + "both_accepted": true, + "box_families": [ + "nondispatchable_real_power" + ], + "component_cost_absolute_residuals": {}, + "cost_schemas_match": true, + "equivalent": true, + "explicit": { + "accepted": true, + "binding_probes": [ + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "family": "nondispatchable_real_power", + "fixed_coordinates": 2, + "lower_face_coordinates": 4, + "maximum_face_residual": 2.373539495457986e-09, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 6, + "values": [ + [ + -3.3836502439235994e-11, + 1.9999999997217413, + -5.399774218321567e-11, + 0.9999999976264605 + ], + [ + 2.999999999972334, + 2.373539495457986e-09, + 2.999999999972334, + 2.766636656776906e-11 + ], + [ + 2.7825861960995294e-10, + 4.000000000053998, + -3.3836502439235994e-11, + 5.000000000034967 + ] + ], + "variable": "p_nd" + } + ], + "canonical_structure": { + "backend": "SCIPY", + "canonical_variables": 16, + "coefficient_columns": 16, + "coefficient_nonzeros": 60, + "coefficient_rows": 48, + "equality_rows": 4, + "nonnegative_rows": 44, + "quadratic_nonzeros": 16, + "reductions": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "soc_dimensions": [] + }, + "classification": "accepted", + "component_costs": {}, + "device_ids": [ + "solar-a", + "wind-b", + "solar-c" + ], + "encoding": "explicit", + "exception": null, + "fixture_sha256": "bec4480f8e5341c2b378cdad94b0da416fe76e25e2cf73217397b82000b07257", + "formulation": "singlenode_dc", + "gate": "nondispatchable", + "objective": 40.99400000026513, + "probe_only_objective_terms": { + "nondispatchable_preference_probe_only": 21.094000000219687 + }, + "process_peak_rss_bytes": { + "after_canonicalization": 112934912, + "after_construction": 111902720, + "after_solve": 113459200 + }, + "public_results": { + "Pg": [ + [ + 17.000000000006015 + ], + [ + 15.000000000008198 + ], + [ + 16.000000000023334 + ], + [ + 15.000000000035834 + ] + ], + "curtailment": [ + [ + -2.471726869616444e-14, + 2.000000000002871, + 3.169464690699897e-12 + ], + [ + 6.24389429049188e-13, + 4.953704113574986e-12, + 2.6223467841646197e-12 + ], + [ + 2.0000000000051714, + 1.8193002659927515e-11, + -2.7402625351897672e-14 + ], + [ + 7.830514014983692e-12, + 3.000000000006512, + 2.149391775674303e-11 + ] + ], + "nondispatchable_injection": [ + [ + 2.471726869616444e-14, + 4.9999999999939595 + ], + [ + 1.9999999999993756, + 4.999999999992424 + ], + [ + 3.9999999999948286, + 2.9999999999818345 + ], + [ + 0.9999999999921695, + 7.999999999971994 + ] + ], + "p_nd": [ + [ + 2.471726869616444e-14, + 2.999999999997129, + 1.9999999999968305 + ], + [ + 1.9999999999993756, + 0.9999999999950463, + 3.9999999999973777 + ], + [ + 3.9999999999948286, + 2.999999999981807, + 2.7402625351897672e-14 + ], + [ + 0.9999999999921695, + 2.999999999993488, + 4.999999999978506 + ] + ], + "p_net": [ + 0.0, + -3.552713678800501e-15, + -3.552713678800501e-15, + 0.0 + ] + }, + "residuals": { + "active_balance_abs": 3.552713678800501e-15, + "availability_abs": 2.7402625351897672e-14, + "component_injection_abs": 0.0, + "curtailment_abs": 0.0, + "curtailment_nonnegative_abs": 2.7402625351897672e-14, + "nondispatchable_preference_probe_only_abs": 0.0, + "nondispatchable_real_power_box_abs": 2.7402625351897672e-14, + "objective_reconstruction_abs": 0.0, + "p_net_reconstruction_abs": 0.0, + "rating_abs": 0.0 + }, + "solve_time": 0.000106041, + "solver": "CLARABEL", + "solver_iterations": 9, + "source_structure": { + "all_constraints_dcp": true, + "constraint_objects": 6, + "equality_objects": 1, + "explicit_inequality_objects": 5, + "explicit_scalar_inequalities": 44, + "objective_is_dcp": true, + "problem_is_dcp": true, + "scalar_equalities": 4, + "scalar_variables": 16, + "variable_objects": 2, + "variable_shapes": { + "Pg": [ + 1, + 4 + ], + "p_nd": [ + 3, + 4 + ] + } + }, + "status": "optimal", + "timing_seconds": { + "canonicalization": 0.004938208032399416, + "construction": 0.0012657499173656106, + "solve": 0.0005827499553561211 + } + }, + "fixture_fingerprints_match": true, + "fixture_sha256": "bec4480f8e5341c2b378cdad94b0da416fe76e25e2cf73217397b82000b07257", + "formulation": "singlenode_dc", + "gate": "nondispatchable", + "leaf": { + "accepted": true, + "binding_probes": [ + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "family": "nondispatchable_real_power", + "fixed_coordinates": 2, + "lower_face_coordinates": 4, + "maximum_face_residual": 2.3735440869585647e-09, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 6, + "values": [ + [ + 0.0, + 1.9999999997217406, + 0.0, + 0.999999997626456 + ], + [ + 2.9999999999723332, + 2.3735440869585647e-09, + 2.9999999999723332, + 2.766653065476649e-11 + ], + [ + 2.782592566431233e-10, + 4.0, + 0.0, + 5.0 + ] + ], + "variable": "p_nd" + } + ], + "canonical_structure": { + "backend": "SCIPY", + "canonical_variables": 16, + "coefficient_columns": 16, + "coefficient_nonzeros": 48, + "coefficient_rows": 36, + "equality_rows": 4, + "nonnegative_rows": 32, + "quadratic_nonzeros": 16, + "reductions": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "soc_dimensions": [] + }, + "classification": "accepted", + "component_costs": {}, + "device_ids": [ + "solar-a", + "wind-b", + "solar-c" + ], + "encoding": "leaf", + "exception": null, + "fixture_sha256": "bec4480f8e5341c2b378cdad94b0da416fe76e25e2cf73217397b82000b07257", + "formulation": "singlenode_dc", + "gate": "nondispatchable", + "objective": 40.99400000202103, + "probe_only_objective_terms": { + "nondispatchable_preference_probe_only": 21.09400000167124 + }, + "process_peak_rss_bytes": { + "after_canonicalization": 112017408, + "after_construction": 111034368, + "after_solve": 112541696 + }, + "public_results": { + "Pg": [ + [ + 17.00000000012747 + ], + [ + 15.000000000157016 + ], + [ + 16.000000000121293 + ], + [ + 15.000000000152124 + ] + ], + "curtailment": [ + [ + 0.0, + 2.000000000066174, + 6.142020225752276e-11 + ], + [ + 6.222733439642525e-11, + 4.1836978326159624e-11, + 5.2950532847262366e-11 + ], + [ + 2.0000000000546105, + 6.680700437300402e-11, + 0.0 + ], + [ + 3.2682967443520283e-11, + 3.0000000000682117, + 5.1231907605142624e-11 + ] + ], + "nondispatchable_injection": [ + [ + 0.0, + 4.999999999872406 + ], + [ + 1.9999999999377727, + 4.999999999905213 + ], + [ + 3.9999999999453895, + 2.999999999933193 + ], + [ + 0.999999999967317, + 7.999999999880556 + ] + ], + "p_nd": [ + [ + 0.0, + 2.999999999933826, + 1.9999999999385798 + ], + [ + 1.9999999999377727, + 0.999999999958163, + 3.9999999999470495 + ], + [ + 3.9999999999453895, + 2.999999999933193, + 0.0 + ], + [ + 0.999999999967317, + 2.9999999999317883, + 4.999999999948768 + ] + ], + "p_net": [ + -1.2079226507921703e-13, + 0.0, + -1.2434497875801753e-13, + -3.552713678800501e-15 + ] + }, + "residuals": { + "active_balance_abs": 1.2434497875801753e-13, + "availability_abs": 0.0, + "component_injection_abs": 0.0, + "curtailment_abs": 0.0, + "curtailment_nonnegative_abs": 0.0, + "nondispatchable_preference_probe_only_abs": 0.0, + "nondispatchable_real_power_box_abs": 0.0, + "objective_reconstruction_abs": 0.0, + "p_net_reconstruction_abs": 0.0, + "rating_abs": 0.0 + }, + "solve_time": 0.000102834, + "solver": "CLARABEL", + "solver_iterations": 9, + "source_structure": { + "all_constraints_dcp": true, + "constraint_objects": 3, + "equality_objects": 1, + "explicit_inequality_objects": 2, + "explicit_scalar_inequalities": 8, + "objective_is_dcp": true, + "problem_is_dcp": true, + "scalar_equalities": 4, + "scalar_variables": 16, + "variable_objects": 2, + "variable_shapes": { + "Pg": [ + 1, + 4 + ], + "p_nd": [ + 3, + 4 + ] + } + }, + "status": "optimal", + "timing_seconds": { + "canonicalization": 0.005596457980573177, + "construction": 0.0016547500854358077, + "solve": 0.0006232919404283166 + } + }, + "objective_absolute_residual": 1.7559003140377172e-09, + "probe_only_objective_term_absolute_residuals": { + "nondispatchable_preference_probe_only": 1.4515535440295935e-09 + }, + "probe_only_objective_term_schemas_match": true, + "public_result_absolute_residuals": { + "Pg": 1.4881784693443478e-10, + "curtailment": 6.330314050728703e-11, + "nondispatchable_injection": 1.2155343398490004e-10, + "p_nd": 6.330314050728703e-11, + "p_net": 1.2079226507921703e-13 + }, + "result_schemas_match": true + }, + { + "binding_probe_absolute_residuals": { + "load_shed_fraction": 6.254899226519224e-12 + }, + "binding_probes_passed": true, + "both_accepted": true, + "box_families": [ + "load_shed_fraction" + ], + "component_cost_absolute_residuals": { + "load_shedding_cost": 7.503331289626658e-12 + }, + "cost_schemas_match": true, + "equivalent": true, + "explicit": { + "accepted": true, + "binding_probes": [ + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "family": "load_shed_fraction", + "fixed_coordinates": 2, + "lower_face_coordinates": 3, + "maximum_face_residual": 6.434451924731443e-11, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 3, + "values": [ + [ + -6.254899226519224e-12, + 0.4999999999485172, + 5.1482843523790144e-11, + 0.4999999999485172 + ], + [ + 0.2499999999356555, + 6.434451924731443e-11, + 6.2548992265159655e-12, + 6.434451924731443e-11 + ] + ], + "variable": "load_shed_fraction" + } + ], + "canonical_structure": { + "backend": "SCIPY", + "canonical_variables": 20, + "coefficient_columns": 20, + "coefficient_nonzeros": 64, + "coefficient_rows": 48, + "equality_rows": 8, + "nonnegative_rows": 40, + "quadratic_nonzeros": 20, + "reductions": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "soc_dimensions": [] + }, + "classification": "accepted", + "component_costs": { + "load_shedding_cost": 390.000000042962 + }, + "device_ids": [ + "industrial", + "commercial" + ], + "encoding": "explicit", + "exception": null, + "fixture_sha256": "b89086efe1372ee87c03d110b40f4d49fd17d8d521696e7d91c9ca34220e3aa7", + "formulation": "lossy_dc", + "gate": "load_shedding", + "objective": 399.5828164719121, + "probe_only_objective_terms": {}, + "process_peak_rss_bytes": { + "after_canonicalization": 112295936, + "after_construction": 111214592, + "after_solve": 112820224 + }, + "public_results": { + "Pg": [ + [ + 6.249999999995496, + 6.249999999996156 + ], + [ + 7.999999999967445, + 7.999999999967445 + ], + [ + 8.49999999997652, + 8.499999999976447 + ], + [ + 7.9999999999632525, + 7.99999999996358 + ] + ], + "energy_not_served": 3.5000000001936695, + "energy_not_served_by_load": [ + 2.9999999998987317, + 0.5000000002949379 + ], + "load_injection": [ + [ + -7.999999999999945, + -4.499999999991703 + ], + [ + -9.000000000072173, + -6.999999999862714 + ], + [ + -10.999999999952891, + -6.000000000000075 + ], + [ + -8.000000000076257, + -7.999999999850571 + ] + ], + "load_shed_fraction": [ + [ + 6.830358912666955e-15, + 0.10000000000165955 + ], + [ + 0.09999999999278257, + 1.9612242914788386e-11 + ], + [ + 0.08333333333725909, + -1.2363603287904836e-14 + ], + [ + 0.11111111110263804, + 1.8678561580413834e-11 + ] + ], + "p_flows": [ + [ + -1.7500000000044522 + ], + [ + -1.0000000001047311 + ], + [ + -2.4999999999763736 + ], + [ + -1.1300607060719838e-10 + ] + ], + "p_load": [ + [ + 8.0, + 5.0 + ], + [ + 10.0, + 7.0 + ], + [ + 12.0, + 6.0 + ], + [ + 9.0, + 8.0 + ] + ], + "p_load_served": [ + [ + 7.999999999999945, + 4.499999999991703 + ], + [ + 9.000000000072173, + 6.999999999862714 + ], + [ + 10.999999999952891, + 6.000000000000075 + ], + [ + 8.000000000076257, + 7.999999999850571 + ] + ], + "p_load_shed": [ + [ + 5.464287130133564e-14, + 0.5000000000082978 + ], + [ + 0.9999999999278257, + 1.372857004035187e-10 + ], + [ + 1.000000000047109, + -7.418161972742902e-14 + ], + [ + 0.9999999999237423, + 1.4942849264331067e-10 + ] + ], + "p_load_shed_total": [ + 0.5000000000083524, + 1.0000000000651115, + 1.0000000000470348, + 1.0000000000731708 + ], + "p_net": [ + [ + -1.7500000000044489, + 1.7500000000044533 + ], + [ + -1.0000000001047287, + 1.0000000001047304 + ], + [ + -2.499999999976371, + 2.4999999999763727 + ], + [ + -1.1300471669528633e-10, + 1.1300915758738483e-10 + ] + ], + "q_load": [ + [ + 2.4, + 1.0 + ], + [ + 3.0, + 1.4 + ], + [ + 3.6, + 1.2 + ], + [ + 2.7, + 1.6 + ] + ] + }, + "residuals": { + "active_balance_abs": 3.3306690738754696e-15, + "component_injection_abs": 0.0, + "eligibility_abs": 6.830358912666955e-15, + "energy_not_served_abs": 0.0, + "energy_not_served_by_load_abs": 0.0, + "ineligible_fraction_abs": 1.2363603287904836e-14, + "load_shed_fraction_box_abs": 1.2363603287904836e-14, + "objective_reconstruction_abs": 0.0, + "p_net_reconstruction_abs": 0.0, + "q_load_reconstruction_abs": 0.0, + "served_reconstruction_abs": 0.0, + "shed_reconstruction_abs": 0.0, + "shed_total_reconstruction_abs": 0.0, + "shedding_cost_abs": 0.0 + }, + "solve_time": 0.000211959, + "solver": "CLARABEL", + "solver_iterations": 11, + "source_structure": { + "all_constraints_dcp": true, + "constraint_objects": 8, + "equality_objects": 2, + "explicit_inequality_objects": 6, + "explicit_scalar_inequalities": 40, + "objective_is_dcp": true, + "problem_is_dcp": true, + "scalar_equalities": 8, + "scalar_variables": 20, + "variable_objects": 3, + "variable_shapes": { + "Pg": [ + 2, + 4 + ], + "load_shed_fraction": [ + 2, + 4 + ], + "p_flows": [ + 1, + 4 + ] + } + }, + "status": "optimal", + "timing_seconds": { + "canonicalization": 0.007278374978341162, + "construction": 0.001766999950632453, + "solve": 0.000786959077231586 + } + }, + "fixture_fingerprints_match": true, + "fixture_sha256": "b89086efe1372ee87c03d110b40f4d49fd17d8d521696e7d91c9ca34220e3aa7", + "formulation": "lossy_dc", + "gate": "load_shedding", + "leaf": { + "accepted": true, + "binding_probes": [ + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "family": "load_shed_fraction", + "fixed_coordinates": 2, + "lower_face_coordinates": 3, + "maximum_face_residual": 6.434458521553665e-11, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 3, + "values": [ + [ + 0.0, + 0.49999999994851707, + 5.148289058692402e-11, + 0.49999999994851707 + ], + [ + 0.24999999993565541, + 6.434456706754206e-11, + 0.0, + 6.434456706754206e-11 + ] + ], + "variable": "load_shed_fraction" + } + ], + "canonical_structure": { + "backend": "SCIPY", + "canonical_variables": 20, + "coefficient_columns": 20, + "coefficient_nonzeros": 64, + "coefficient_rows": 48, + "equality_rows": 8, + "nonnegative_rows": 40, + "quadratic_nonzeros": 20, + "reductions": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "soc_dimensions": [] + }, + "classification": "accepted", + "component_costs": { + "load_shedding_cost": 390.0000000429695 + }, + "device_ids": [ + "industrial", + "commercial" + ], + "encoding": "leaf", + "exception": null, + "fixture_sha256": "b89086efe1372ee87c03d110b40f4d49fd17d8d521696e7d91c9ca34220e3aa7", + "formulation": "lossy_dc", + "gate": "load_shedding", + "objective": 399.5828164719196, + "probe_only_objective_terms": {}, + "process_peak_rss_bytes": { + "after_canonicalization": 112328704, + "after_construction": 111214592, + "after_solve": 112885760 + }, + "public_results": { + "Pg": [ + [ + 6.249999999995495, + 6.249999999996155 + ], + [ + 7.999999999967444, + 7.999999999967444 + ], + [ + 8.499999999976517, + 8.499999999976446 + ], + [ + 7.999999999963251, + 7.9999999999635785 + ] + ], + "energy_not_served": 3.5000000001936873, + "energy_not_served_by_load": [ + 2.9999999998986784, + 0.500000000295009 + ], + "load_injection": [ + [ + -8.0, + -4.499999999991705 + ], + [ + -9.000000000072175, + -6.999999999862714 + ], + [ + -10.999999999952887, + -6.0 + ], + [ + -8.000000000076259, + -7.999999999850571 + ] + ], + "load_shed_fraction": [ + [ + 0.0, + 0.10000000000165896 + ], + [ + 0.09999999999278243, + 1.9612246765512493e-11 + ], + [ + 0.08333333333725937, + 0.0 + ], + [ + 0.11111111110263797, + 1.867856524413325e-11 + ] + ], + "p_flows": [ + [ + -1.75000000000445 + ], + [ + -1.0000000001047311 + ], + [ + -2.499999999976372 + ], + [ + -1.1300719111793213e-10 + ] + ], + "p_load": [ + [ + 8.0, + 5.0 + ], + [ + 10.0, + 7.0 + ], + [ + 12.0, + 6.0 + ], + [ + 9.0, + 8.0 + ] + ], + "p_load_served": [ + [ + 8.0, + 4.499999999991705 + ], + [ + 9.000000000072175, + 6.999999999862714 + ], + [ + 10.999999999952887, + 6.0 + ], + [ + 8.000000000076259, + 7.999999999850571 + ] + ], + "p_load_shed": [ + [ + 0.0, + 0.5000000000082948 + ], + [ + 0.9999999999278243, + 1.3728572735858744e-10 + ], + [ + 1.0000000000471125, + 0.0 + ], + [ + 0.9999999999237417, + 1.49428521953066e-10 + ] + ], + "p_load_shed_total": [ + 0.5000000000082948, + 1.00000000006511, + 1.0000000000471125, + 1.0000000000731701 + ], + "p_net": [ + [ + -1.7500000000045048, + 1.7500000000044498 + ], + [ + -1.0000000001047313, + 1.0000000001047296 + ], + [ + -2.499999999976371, + 2.4999999999764455 + ], + [ + -1.1300826940896513e-10, + 1.1300738123054543e-10 + ] + ], + "q_load": [ + [ + 2.4, + 1.0 + ], + [ + 3.0, + 1.4 + ], + [ + 3.6, + 1.2 + ], + [ + 2.7, + 1.6 + ] + ] + }, + "residuals": { + "active_balance_abs": 7.37188088351104e-14, + "component_injection_abs": 0.0, + "eligibility_abs": 0.0, + "energy_not_served_abs": 0.0, + "energy_not_served_by_load_abs": 0.0, + "ineligible_fraction_abs": 0.0, + "load_shed_fraction_box_abs": 0.0, + "objective_reconstruction_abs": 0.0, + "p_net_reconstruction_abs": 0.0, + "q_load_reconstruction_abs": 0.0, + "served_reconstruction_abs": 0.0, + "shed_reconstruction_abs": 0.0, + "shed_total_reconstruction_abs": 0.0, + "shedding_cost_abs": 0.0 + }, + "solve_time": 0.000134375, + "solver": "CLARABEL", + "solver_iterations": 11, + "source_structure": { + "all_constraints_dcp": true, + "constraint_objects": 6, + "equality_objects": 2, + "explicit_inequality_objects": 4, + "explicit_scalar_inequalities": 24, + "objective_is_dcp": true, + "problem_is_dcp": true, + "scalar_equalities": 8, + "scalar_variables": 20, + "variable_objects": 3, + "variable_shapes": { + "Pg": [ + 2, + 4 + ], + "load_shed_fraction": [ + 2, + 4 + ], + "p_flows": [ + 1, + 4 + ] + } + }, + "status": "optimal", + "timing_seconds": { + "canonicalization": 0.007251625065691769, + "construction": 0.0016542919911444187, + "solve": 0.0006534589920192957 + } + }, + "objective_absolute_residual": 7.503331289626658e-12, + "probe_only_objective_term_absolute_residuals": {}, + "probe_only_objective_term_schemas_match": true, + "public_result_absolute_residuals": { + "Pg": 3.552713678800501e-15, + "energy_not_served": 1.7763568394002505e-14, + "energy_not_served_by_load": 7.116529587847253e-14, + "load_injection": 7.460698725481052e-14, + "load_shed_fraction": 1.2363603287904836e-14, + "p_flows": 2.220446049250313e-15, + "p_load": 0.0, + "p_load_served": 7.460698725481052e-14, + "p_load_shed": 7.418161972742902e-14, + "p_load_shed_total": 7.771561172376096e-14, + "p_net": 7.283063041541027e-14, + "q_load": 0.0 + }, + "result_schemas_match": true + }, + { + "binding_probe_absolute_residuals": { + "load_shed_fraction": 6.254899226519224e-12 + }, + "binding_probes_passed": true, + "both_accepted": true, + "box_families": [ + "load_shed_fraction" + ], + "component_cost_absolute_residuals": { + "load_shedding_cost": 4.240519047016278e-11 + }, + "cost_schemas_match": true, + "equivalent": true, + "explicit": { + "accepted": true, + "binding_probes": [ + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "family": "load_shed_fraction", + "fixed_coordinates": 2, + "lower_face_coordinates": 3, + "maximum_face_residual": 6.434451924731443e-11, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 3, + "values": [ + [ + -6.254899226519224e-12, + 0.4999999999485172, + 5.1482843523790144e-11, + 0.4999999999485172 + ], + [ + 0.2499999999356555, + 6.434451924731443e-11, + 6.2548992265159655e-12, + 6.434451924731443e-11 + ] + ], + "variable": "load_shed_fraction" + } + ], + "canonical_structure": { + "backend": "SCIPY", + "canonical_variables": 12, + "coefficient_columns": 12, + "coefficient_nonzeros": 36, + "coefficient_rows": 28, + "equality_rows": 4, + "nonnegative_rows": 24, + "quadratic_nonzeros": 12, + "reductions": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "soc_dimensions": [] + }, + "classification": "accepted", + "component_costs": { + "load_shedding_cost": 390.00000000501655 + }, + "device_ids": [ + "industrial", + "commercial" + ], + "encoding": "explicit", + "exception": null, + "fixture_sha256": "a40c87810d98045ea05191b341d43bbacc07f3695cc99e1d1d7af072acb9cb74", + "formulation": "singlenode_dc", + "gate": "load_shedding", + "objective": 409.1450039340127, + "probe_only_objective_terms": {}, + "process_peak_rss_bytes": { + "after_canonicalization": 111804416, + "after_construction": 110788608, + "after_solve": 112328704 + }, + "public_results": { + "Pg": [ + [ + 12.499999999998886 + ], + [ + 15.999999999991159 + ], + [ + 16.999999999992706 + ], + [ + 15.999999999992237 + ] + ], + "energy_not_served": 3.500000000025018, + "energy_not_served_by_load": [ + 2.9999999999935842, + 0.500000000031434 + ], + "load_injection": [ + [ + -7.999999999999578, + -4.499999999999306 + ], + [ + -9.00000000000639, + -6.999999999984768 + ], + [ + -10.999999999992703, + -6.0 + ], + [ + -8.000000000007747, + -7.999999999984492 + ] + ], + "load_shed_fraction": [ + [ + 5.2773174955774137e-14, + 0.10000000000013873 + ], + [ + 0.09999999999936103, + 2.17597637432524e-12 + ], + [ + 0.08333333333394147, + 7.265985122614426e-17 + ], + [ + 0.11111111111025043, + 1.938504298374829e-12 + ] + ], + "p_load": [ + [ + 8.0, + 5.0 + ], + [ + 10.0, + 7.0 + ], + [ + 12.0, + 6.0 + ], + [ + 9.0, + 8.0 + ] + ], + "p_load_served": [ + [ + 7.999999999999578, + 4.499999999999306 + ], + [ + 9.00000000000639, + 6.999999999984768 + ], + [ + 10.999999999992703, + 6.0 + ], + [ + 8.000000000007747, + 7.999999999984492 + ] + ], + "p_load_shed": [ + [ + 4.221853996461931e-13, + 0.5000000000006937 + ], + [ + 0.9999999999936103, + 1.523183462027668e-11 + ], + [ + 1.0000000000072977, + 4.359591073568656e-16 + ], + [ + 0.9999999999922539, + 1.5508034386998633e-11 + ] + ], + "p_load_shed_total": [ + 0.5000000000011159, + 1.0000000000088423, + 1.0000000000072982, + 1.0000000000077618 + ], + "p_net": [ + 1.7763568394002505e-15, + 1.7763568394002505e-15, + 3.552713678800501e-15, + -1.7763568394002505e-15 + ], + "q_load": [ + [ + 2.4, + 1.0 + ], + [ + 3.0, + 1.4 + ], + [ + 3.6, + 1.2 + ], + [ + 2.7, + 1.6 + ] + ] + }, + "residuals": { + "active_balance_abs": 3.552713678800501e-15, + "component_injection_abs": 0.0, + "eligibility_abs": 5.2773174955774137e-14, + "energy_not_served_abs": 4.440892098500626e-16, + "energy_not_served_by_load_abs": 0.0, + "ineligible_fraction_abs": 5.2773174955774137e-14, + "load_shed_fraction_box_abs": 5.2773174955774137e-14, + "objective_reconstruction_abs": 0.0, + "p_net_reconstruction_abs": 0.0, + "q_load_reconstruction_abs": 0.0, + "served_reconstruction_abs": 0.0, + "shed_reconstruction_abs": 0.0, + "shed_total_reconstruction_abs": 0.0, + "shedding_cost_abs": 0.0 + }, + "solve_time": 8.4042e-05, + "solver": "CLARABEL", + "solver_iterations": 9, + "source_structure": { + "all_constraints_dcp": true, + "constraint_objects": 5, + "equality_objects": 1, + "explicit_inequality_objects": 4, + "explicit_scalar_inequalities": 24, + "objective_is_dcp": true, + "problem_is_dcp": true, + "scalar_equalities": 4, + "scalar_variables": 12, + "variable_objects": 2, + "variable_shapes": { + "Pg": [ + 1, + 4 + ], + "load_shed_fraction": [ + 2, + 4 + ] + } + }, + "status": "optimal", + "timing_seconds": { + "canonicalization": 0.005594833055511117, + "construction": 0.001319041009992361, + "solve": 0.0005341250216588378 + } + }, + "fixture_fingerprints_match": true, + "fixture_sha256": "a40c87810d98045ea05191b341d43bbacc07f3695cc99e1d1d7af072acb9cb74", + "formulation": "singlenode_dc", + "gate": "load_shedding", + "leaf": { + "accepted": true, + "binding_probes": [ + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "family": "load_shed_fraction", + "fixed_coordinates": 2, + "lower_face_coordinates": 3, + "maximum_face_residual": 6.434458521553665e-11, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 3, + "values": [ + [ + 0.0, + 0.49999999994851707, + 5.148289058692402e-11, + 0.49999999994851707 + ], + [ + 0.24999999993565541, + 6.434456706754206e-11, + 0.0, + 6.434456706754206e-11 + ] + ], + "variable": "load_shed_fraction" + } + ], + "canonical_structure": { + "backend": "SCIPY", + "canonical_variables": 12, + "coefficient_columns": 12, + "coefficient_nonzeros": 36, + "coefficient_rows": 28, + "equality_rows": 4, + "nonnegative_rows": 24, + "quadratic_nonzeros": 12, + "reductions": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "soc_dimensions": [] + }, + "classification": "accepted", + "component_costs": { + "load_shedding_cost": 390.00000000497414 + }, + "device_ids": [ + "industrial", + "commercial" + ], + "encoding": "leaf", + "exception": null, + "fixture_sha256": "a40c87810d98045ea05191b341d43bbacc07f3695cc99e1d1d7af072acb9cb74", + "formulation": "singlenode_dc", + "gate": "load_shedding", + "objective": 409.1450039339703, + "probe_only_objective_terms": {}, + "process_peak_rss_bytes": { + "after_canonicalization": 111837184, + "after_construction": 110821376, + "after_solve": 112410624 + }, + "public_results": { + "Pg": [ + [ + 12.499999999998886 + ], + [ + 15.999999999991159 + ], + [ + 16.999999999992706 + ], + [ + 15.999999999992239 + ] + ], + "energy_not_served": 3.5000000000245945, + "energy_not_served_by_load": [ + 2.9999999999931606, + 0.5000000000314337 + ], + "load_injection": [ + [ + -8.0, + -4.499999999999306 + ], + [ + -9.00000000000639, + -6.999999999984768 + ], + [ + -10.999999999992705, + -6.0 + ], + [ + -8.000000000007747, + -7.9999999999844915 + ] + ], + "load_shed_fraction": [ + [ + 0.0, + 0.10000000000013873 + ], + [ + 0.09999999999936107, + 2.17598727536939e-12 + ], + [ + 0.08333333333394134, + 0.0 + ], + [ + 0.1111111111102504, + 1.9385135530143673e-12 + ] + ], + "p_load": [ + [ + 8.0, + 5.0 + ], + [ + 10.0, + 7.0 + ], + [ + 12.0, + 6.0 + ], + [ + 9.0, + 8.0 + ] + ], + "p_load_served": [ + [ + 8.0, + 4.499999999999306 + ], + [ + 9.00000000000639, + 6.999999999984768 + ], + [ + 10.999999999992705, + 6.0 + ], + [ + 8.000000000007747, + 7.9999999999844915 + ] + ], + "p_load_shed": [ + [ + 0.0, + 0.5000000000006937 + ], + [ + 0.9999999999936107, + 1.5231910927585727e-11 + ], + [ + 1.0000000000072962, + 0.0 + ], + [ + 0.9999999999922536, + 1.550810842411494e-11 + ] + ], + "p_load_shed_total": [ + 0.5000000000006937, + 1.0000000000088425, + 1.0000000000072962, + 1.0000000000077618 + ], + "p_net": [ + -4.2099657093785936e-13, + 1.7763568394002505e-15, + 3.552713678800501e-15, + 1.7763568394002505e-15 + ], + "q_load": [ + [ + 2.4, + 1.0 + ], + [ + 3.0, + 1.4 + ], + [ + 3.6, + 1.2 + ], + [ + 2.7, + 1.6 + ] + ] + }, + "residuals": { + "active_balance_abs": 4.2099657093785936e-13, + "component_injection_abs": 0.0, + "eligibility_abs": 0.0, + "energy_not_served_abs": 8.881784197001252e-16, + "energy_not_served_by_load_abs": 0.0, + "ineligible_fraction_abs": 0.0, + "load_shed_fraction_box_abs": 0.0, + "objective_reconstruction_abs": 0.0, + "p_net_reconstruction_abs": 0.0, + "q_load_reconstruction_abs": 0.0, + "served_reconstruction_abs": 0.0, + "shed_reconstruction_abs": 0.0, + "shed_total_reconstruction_abs": 0.0, + "shedding_cost_abs": 0.0 + }, + "solve_time": 8.5957e-05, + "solver": "CLARABEL", + "solver_iterations": 9, + "source_structure": { + "all_constraints_dcp": true, + "constraint_objects": 3, + "equality_objects": 1, + "explicit_inequality_objects": 2, + "explicit_scalar_inequalities": 8, + "objective_is_dcp": true, + "problem_is_dcp": true, + "scalar_equalities": 4, + "scalar_variables": 12, + "variable_objects": 2, + "variable_shapes": { + "Pg": [ + 1, + 4 + ], + "load_shed_fraction": [ + 2, + 4 + ] + } + }, + "status": "optimal", + "timing_seconds": { + "canonicalization": 0.005867250030860305, + "construction": 0.00167720892932266, + "solve": 0.000597959035076201 + } + }, + "objective_absolute_residual": 4.240519047016278e-11, + "probe_only_objective_term_absolute_residuals": {}, + "probe_only_objective_term_schemas_match": true, + "public_result_absolute_residuals": { + "Pg": 1.7763568394002505e-15, + "energy_not_served": 4.2366110619695974e-13, + "energy_not_served_by_load": 4.2366110619695974e-13, + "load_injection": 4.218847493575595e-13, + "load_shed_fraction": 5.2773174955774137e-14, + "p_load": 0.0, + "p_load_served": 4.218847493575595e-13, + "p_load_shed": 4.221853996461931e-13, + "p_load_shed_total": 4.2221781626494703e-13, + "p_net": 4.227729277772596e-13, + "q_load": 0.0 + }, + "result_schemas_match": true + }, + { + "binding_probe_absolute_residuals": { + "hvdc_input_power": 3.5291769506784476e-11 + }, + "binding_probes_passed": true, + "both_accepted": true, + "box_families": [ + "hvdc_input_power" + ], + "component_cost_absolute_residuals": { + "hvdc_cost": 0.0 + }, + "cost_schemas_match": true, + "equivalent": true, + "explicit": { + "accepted": true, + "binding_probes": [ + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "family": "hvdc_input_power", + "fixed_coordinates": 4, + "lower_face_coordinates": 8, + "maximum_face_residual": 3.461453346176313e-09, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 8, + "values": [ + [ + 1.0000000000935332, + 4.4999999999726255, + 1.5000000000935336, + 4.9999999999726255 + ], + [ + -0.999999999985501, + -3.9999999999064677, + -0.5000000000273745, + -2.9999999997775766 + ], + [ + -3.000000000027257, + 3.000000000027257, + -3.000000000027257, + 3.000000000027257 + ], + [ + 2.0000000000352918, + 1.9999999999647085, + 2.0000000000352918, + 1.9999999999647085 + ], + [ + 5.178670155489144e-10, + 2.9999999994821334, + 2.0000000005178675, + 1.9999999965385467 + ] + ], + "variable": "p_hvdc_in" + } + ], + "canonical_structure": { + "backend": "SCIPY", + "canonical_variables": 92, + "coefficient_columns": 92, + "coefficient_nonzeros": 280, + "coefficient_rows": 152, + "equality_rows": 48, + "nonnegative_rows": 104, + "quadratic_nonzeros": 52, + "reductions": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "soc_dimensions": [] + }, + "classification": "accepted", + "component_costs": { + "hvdc_cost": 2.3377940632035137 + }, + "device_ids": [ + "positive", + "negative", + "straddling", + "degenerate", + "varying" + ], + "encoding": "explicit", + "exception": null, + "fixture_sha256": "837220c52c5a205072aeb2f3947f7bdc97f49e0a27707ed56847691cae1e696a", + "formulation": "lossy_dc", + "gate": "hvdc", + "objective": 30.437381261168053, + "probe_only_objective_terms": {}, + "process_peak_rss_bytes": { + "after_canonicalization": 112754688, + "after_construction": 111329280, + "after_solve": 113262592 + }, + "public_results": { + "Pg": [ + [ + 12.644562524684206, + 12.528885380871342 + ], + [ + 13.151414257228591, + 13.528237006130245 + ], + [ + 13.107144597384247, + 13.114474767690798 + ], + [ + 13.610621251463456, + 13.985164243773273 + ] + ], + "hvdc_injection": [ + [ + -0.9581054009350055, + 0.7846574953794532 + ], + [ + 8.385040720780248, + -9.064691984139085 + ], + [ + 2.0394588087461196, + -2.2610781738211685 + ], + [ + 8.880238594707608, + -9.476024089944339 + ] + ], + "hvdc_loss": [ + [ + 0.05263157895731174, + 0.0800000000078972, + -0.0, + 0.040816326530612734, + 5.973068639482319e-11 + ], + [ + 0.23284123478325824, + 0.3149220812439246, + -4.440892098500626e-16, + 0.04081632653061229, + 0.09107162080104203 + ], + [ + 0.07894736842703787, + 0.04000000001095, + -0.0, + 0.04081632653061229, + 0.061855670106448546 + ], + [ + 0.2588737839806008, + 0.23565264134477193, + -0.0, + 0.040816326530611846, + 0.060442743380745956 + ] + ], + "p_flows": [ + [ + -2.3135428762507972 + ], + [ + 7.536454978008841 + ], + [ + 0.14660340613036754 + ], + [ + 7.4908598461710625 + ] + ], + "p_hvdc_in": [ + [ + 1.0000000001889218, + -1.0000000000987141, + -2.9581054029565013, + 2.0000000000000018, + 1.9312863875646356e-09 + ], + [ + 4.423983460881908, + -3.9365260155490684, + 2.9529342028803613, + 2.000000000000002, + 2.9446490725670444 + ], + [ + 1.5000000001137261, + -0.5000000001368746, + -2.960541191339242, + 2.0000000000000018, + 2.0000000001085083 + ], + [ + 4.9186018956314115, + -2.9456580168096527, + 2.9529793465750553, + 2.0000000000000027, + 1.9543153693107906 + ] + ], + "p_hvdc_out": [ + [ + -1.0526315791462335, + 0.920000000090817, + 2.9581054029565013, + -2.0408163265306145, + -1.991017073959459e-09 + ], + [ + -4.656824695665167, + 3.621603934305144, + -2.952934202880361, + -2.0408163265306145, + -3.0357206933680865 + ], + [ + -1.578947368540764, + 0.4600000001259246, + 2.960541191339242, + -2.040816326530614, + -2.061855670214957 + ], + [ + -5.177475679612012, + 2.7100053754648807, + -2.9529793465750553, + -2.0408163265306145, + -2.0147581126915366 + ] + ], + "p_net": [ + [ + -2.3135428762508, + 2.3135428762507964 + ], + [ + 7.536454978008841, + -7.536454978008839 + ], + [ + 0.14660340613036738, + -0.14660340613037093 + ], + [ + 7.4908598461710625, + -7.490859846171066 + ] + ] + }, + "residuals": { + "active_balance_abs": 3.552713678800501e-15, + "component_injection_abs": 0.0, + "hvdc_cost_abs": 1.1102230246251565e-16, + "hvdc_coupling_abs": 8.881784197001252e-16, + "hvdc_input_power_box_abs": 2.6645352591003757e-15, + "hvdc_loss_abs": 0.0, + "hvdc_loss_nonnegative_abs": 4.440892098500626e-16, + "objective_reconstruction_abs": 0.0, + "p_net_reconstruction_abs": 0.0 + }, + "solve_time": 0.00030996, + "solver": "CLARABEL", + "solver_iterations": 9, + "source_structure": { + "all_constraints_dcp": true, + "constraint_objects": 13, + "equality_objects": 7, + "explicit_inequality_objects": 6, + "explicit_scalar_inequalities": 64, + "objective_is_dcp": true, + "problem_is_dcp": true, + "scalar_equalities": 28, + "scalar_variables": 52, + "variable_objects": 4, + "variable_shapes": { + "Pg": [ + 2, + 4 + ], + "p_flows": [ + 1, + 4 + ], + "p_hvdc_in": [ + 5, + 4 + ], + "p_hvdc_out": [ + 5, + 4 + ] + } + }, + "status": "optimal", + "timing_seconds": { + "canonicalization": 0.009179375017993152, + "construction": 0.0018984590424224734, + "solve": 0.0008330829441547394 + } + }, + "fixture_fingerprints_match": true, + "fixture_sha256": "837220c52c5a205072aeb2f3947f7bdc97f49e0a27707ed56847691cae1e696a", + "formulation": "lossy_dc", + "gate": "hvdc", + "leaf": { + "accepted": true, + "binding_probes": [ + { + "accepted": true, + "canonicalization_backend": "SCIPY", + "exception": null, + "family": "hvdc_input_power", + "fixed_coordinates": 4, + "lower_face_coordinates": 8, + "maximum_face_residual": 3.4614635602281396e-09, + "solver": "CLARABEL", + "status": "optimal", + "upper_face_coordinates": 8, + "values": [ + [ + 1.000000000093534, + 4.499999999972625, + 1.5000000000935343, + 4.999999999972625 + ], + [ + -1.0, + -3.9999999999064664, + -0.5000000000273751, + -2.9999999997775753 + ], + [ + -3.0, + 3.0, + -3.0, + 3.0 + ], + [ + 2.0, + 2.0, + 2.0, + 2.0 + ], + [ + 5.178689950194441e-10, + 2.9999999994821307, + 2.000000000517869, + 1.9999999965385364 + ] + ], + "variable": "p_hvdc_in" + } + ], + "canonical_structure": { + "backend": "SCIPY", + "canonical_variables": 92, + "coefficient_columns": 92, + "coefficient_nonzeros": 280, + "coefficient_rows": 152, + "equality_rows": 48, + "nonnegative_rows": 104, + "quadratic_nonzeros": 52, + "reductions": [ + "Dcp2Cone", + "CvxAttr2Constr", + "EliminateZeroSized", + "ConeMatrixStuffing", + "CLARABEL" + ], + "soc_dimensions": [] + }, + "classification": "accepted", + "component_costs": { + "hvdc_cost": 2.3377940632035137 + }, + "device_ids": [ + "positive", + "negative", + "straddling", + "degenerate", + "varying" + ], + "encoding": "leaf", + "exception": null, + "fixture_sha256": "837220c52c5a205072aeb2f3947f7bdc97f49e0a27707ed56847691cae1e696a", + "formulation": "lossy_dc", + "gate": "hvdc", + "objective": 30.437381261168053, + "probe_only_objective_terms": {}, + "process_peak_rss_bytes": { + "after_canonicalization": 112623616, + "after_construction": 111214592, + "after_solve": 113164288 + }, + "public_results": { + "Pg": [ + [ + 12.64456252468421, + 12.52888538087134 + ], + [ + 13.151414257228595, + 13.528237006130247 + ], + [ + 13.107144597384247, + 13.114474767690798 + ], + [ + 13.610621251463453, + 13.98516424377327 + ] + ], + "hvdc_injection": [ + [ + -0.958105400935062, + 0.7846574953795096 + ], + [ + 8.385040720780248, + -9.064691984139088 + ], + [ + 2.039458808746111, + -2.261078173821161 + ], + [ + 8.880238594707611, + -9.476024089944342 + ] + ], + "hvdc_loss": [ + [ + 0.05263157895731174, + 0.08000000000789698, + 8.881784197001252e-16, + 0.04081632653061362, + 5.972916941178192e-11 + ], + [ + 0.23284123478325913, + 0.3149220812439255, + -0.0, + 0.04081632653061451, + 0.09107162080104159 + ], + [ + 0.07894736842703809, + 0.04000000001094972, + -0.0, + 0.04081632653061362, + 0.061855670106448546 + ], + [ + 0.2588737839805999, + 0.23565264134477237, + -0.0, + 0.04081632653061451, + 0.0604427433807464 + ] + ], + "p_flows": [ + [ + -2.313542876250851 + ], + [ + 7.536454978008843 + ], + [ + 0.1466034061303621 + ], + [ + 7.490859846171068 + ] + ], + "p_hvdc_in": [ + [ + 1.0000000001889169, + -1.0000000000987115, + -2.958105402956505, + 2.0, + 1.9312373384537184e-09 + ], + [ + 4.423983460881908, + -3.9365260155490707, + 2.952934202880364, + 2.0, + 2.9446490725670458 + ], + [ + 1.5000000001137228, + -0.5000000001368711, + -2.960541191339246, + 2.0, + 2.000000000108505 + ], + [ + 4.918601895631413, + -2.9456580168096544, + 2.952979346575059, + 2.0, + 1.9543153693107924 + ] + ], + "p_hvdc_out": [ + [ + -1.0526315791462286, + 0.9200000000908145, + 2.958105402956504, + -2.0408163265306136, + -1.9909665078655003e-09 + ], + [ + -4.6568246956651675, + 3.621603934305145, + -2.952934202880364, + -2.0408163265306145, + -3.0357206933680874 + ], + [ + -1.578947368540761, + 0.46000000012592135, + 2.960541191339246, + -2.0408163265306136, + -2.0618556702149538 + ], + [ + -5.177475679612013, + 2.710005375464882, + -2.952979346575059, + -2.0408163265306145, + -2.014758112691539 + ] + ], + "p_net": [ + [ + -2.313542876250853, + 2.3135428762508496 + ], + [ + 7.536454978008841, + -7.536454978008841 + ], + [ + 0.1466034061303585, + -0.14660340613036382 + ], + [ + 7.4908598461710625, + -7.490859846171073 + ] + ] + }, + "residuals": { + "active_balance_abs": 5.329070518200751e-15, + "component_injection_abs": 0.0, + "hvdc_cost_abs": 1.1102230246251565e-16, + "hvdc_coupling_abs": 2.220446049250313e-15, + "hvdc_input_power_box_abs": 0.0, + "hvdc_loss_abs": 0.0, + "hvdc_loss_nonnegative_abs": 0.0, + "objective_reconstruction_abs": 0.0, + "p_net_reconstruction_abs": 0.0 + }, + "solve_time": 0.000338918, + "solver": "CLARABEL", + "solver_iterations": 9, + "source_structure": { + "all_constraints_dcp": true, + "constraint_objects": 11, + "equality_objects": 7, + "explicit_inequality_objects": 4, + "explicit_scalar_inequalities": 24, + "objective_is_dcp": true, + "problem_is_dcp": true, + "scalar_equalities": 28, + "scalar_variables": 52, + "variable_objects": 4, + "variable_shapes": { + "Pg": [ + 2, + 4 + ], + "p_flows": [ + 1, + 4 + ], + "p_hvdc_in": [ + 5, + 4 + ], + "p_hvdc_out": [ + 5, + 4 + ] + } + }, + "status": "optimal", + "timing_seconds": { + "canonicalization": 0.009751333040185273, + "construction": 0.001726625021547079, + "solve": 0.0009165839292109013 + } + }, + "objective_absolute_residual": 0.0, + "probe_only_objective_term_absolute_residuals": {}, + "probe_only_objective_term_schemas_match": true, + "public_result_absolute_residuals": { + "Pg": 3.552713678800501e-15, + "hvdc_injection": 5.651035195342047e-14, + "hvdc_loss": 2.6645352591003757e-15, + "p_flows": 5.3734794391857577e-14, + "p_hvdc_in": 4.9049110917245606e-14, + "p_hvdc_out": 5.0566093958508304e-14, + "p_net": 5.3290705182007514e-14 + }, + "result_schemas_match": true + } + ], + "schema_version": 1, + "solver": "CLARABEL", + "solver_options": { + "max_iter": 500, + "tol_feas": 1e-09, + "tol_gap_abs": 1e-09, + "tol_gap_rel": 1e-09 + }, + "stage": "M14b_component_box_qualification" +} From a56a98edfa7c62011fdbac40e5769eb3a14deacc Mon Sep 17 00:00:00 2001 From: Bennet Meyers Date: Fri, 28 Aug 2026 11:52:18 -0700 Subject: [PATCH 26/28] docs(m14b): close component-bound qualification Bind the authoritative execution and promoted result, freeze all nine tested lossy-DC and single-node leaf-bound decisions, and mark M14b complete with M14c next. Preserve explicit AC boxes and make no runtime or RSS claim. --- CLAUDE.md | 2 +- .../m14_time_vectorization/M14B_PROTOCOL.md | 38 +++++++++++++------ plans/milestone-14-time-vectorization.md | 24 ++++++++++-- 3 files changed, 49 insertions(+), 15 deletions(-) diff --git a/CLAUDE.md b/CLAUDE.md index 501d6f2..f7f289c 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -737,7 +737,7 @@ is present. | 11 — SOCP (convex) network model | 🔲 Future | | | 12 — Extend battery parameters: final SoC, penalty vs constraint | ✅ Complete | Storage-owned terminal equality or zero-shortfall constraints and linear/quadratic, one-/two-sided terminal costs, consistently composed across formulations. See `plans/milestone-12-storage-terminal-soc.md`. | | 13 — Extend CVXPY parameterization for problem data | 🔲 Future | Faster repeated solves of the same graph over new data | -| 14 — Time-vectorized multistep formulations | 🟧 M14b open / blocking | M14a's frozen legacy baseline and M14a.1's formulation-specific leaf-bound qualification are complete. M14b is implementing the explicit time-last tensor assembly mode using SCIPY canonicalization alongside the retained stepwise/CPP path. Lossy DC and single-node DC may use the qualified generator/network leaf boxes; storage, nondispatchable, and load-shedding boxes—and lossy-DC HVDC boxes—require focused convex qualification, while AC permits no new leaf-bound migration. Vectorized lossy DC remains the first delivery and blocks resumption of the Case118 annual S4 outer solve after macOS killed the repeated annual graph under extreme compressed-memory pressure. See `plans/milestone-14-time-vectorization.md` and `experiments/m14_time_vectorization/M14B_PROTOCOL.md`. | +| 14 — Time-vectorized multistep formulations | 🟧 M14b complete / M14c next | M14a's frozen legacy baseline, M14a.1's formulation-specific leaf-bound qualification, and M14b's explicit time-last assembly contract are complete. Under SCIPY canonicalization with CLARABEL, the tested lossy-DC and single-node generator, network, storage, nondispatchable, load-shedding, and lossy-DC HVDC boxes select leaf bounds; AC permits no new leaf-bound migration. M14c's vectorized lossy-DC builder remains the first formulation delivery and blocks resumption of the Case118 annual S4 outer solve. See `plans/milestone-14-time-vectorization.md` and `experiments/m14_time_vectorization/M14B_PROTOCOL.md`. | | 15 — Full lossy HVDC (sign-switching converter losses) | 🔲 Future | charge/discharge-style split of `p_in`; adds fixed converter loss (`LOSS0`); enables losses in `free` and zero-straddling `band` steps; reactive-power support proposed. See `plans/milestone-15-full-lossy-hvdc.md`. | | 16 — Unify grid component model patterns | ✅ Complete | Generators, storage, nondispatchable units, and HVDC share formulation-specific injection and operating-set APIs, temporal coupling slots, and device-owned cost boundaries. Includes first-class `DispatchableGenerator`, MATPOWER fallback, stable identity for external ND/HVDC tables, and collapsed singlenode reuse. See `plans/milestone-16-unify-components.md` and `memories/M16-in-flight-record.md`. | | 17 — Hierarchical DC→AC receding-horizon dispatch | ✅ Complete | The capstone controller passes **identity-aligned SoC signposts only** (not other setpoints) from long-horizon `lossy_dc` planning into short AC-OPF windows, executes only residual-checked target-conditioned first actions, supports causal shifted initialization with audited recovery, and retains the complete plan/attempt tree. M17 fixes the validated `lossy_dc`→`ac` workflow; configurable formulations and additional layers are M21. See `plans/milestone-17-hierarchical-dc-ac.md`. | diff --git a/experiments/m14_time_vectorization/M14B_PROTOCOL.md b/experiments/m14_time_vectorization/M14B_PROTOCOL.md index 3a8e575..0727836 100644 --- a/experiments/m14_time_vectorization/M14B_PROTOCOL.md +++ b/experiments/m14_time_vectorization/M14B_PROTOCOL.md @@ -2,19 +2,29 @@ ## Status and authority -M14b is open. It is authorized by the immutable M14a legacy baseline and the -M14a.1 leaf-bound qualification record. The typed horizon, one-call assembly, -aggregation/publication, and compatibility-result projection slices are now -implemented. The reusable component-box probe harness, seven formulation-local -gates, fresh-process runner, and immutable result schema are implemented; the -clean authoritative execution is next. M14b keeps the public stepwise/CPP path -available and unchanged by default. +M14b is complete. It is authorized by the immutable M14a legacy baseline and +the M14a.1 leaf-bound qualification record. The typed horizon, one-call +assembly, aggregation/publication, compatibility-result projection, and +component-box qualification slices are complete. M14b keeps the public +stepwise/CPP path available and unchanged by default, and hands the frozen +assembly contract to M14c. + +The authoritative component-box record was executed from commit +`028b46e2f0af16fbff90a9bc991770f0267280a5`, has source fingerprint +`45e2e91e95594b3418065c256ef476c70d14f7f679d1606a71f2fc34c57ac03b`, and +is promoted as `M14B_COMPONENT_BOX_RESULTS.json` with SHA-256 +`2bdf5eda5d545a49e66afd01eeca7083bd3d81d54dfb5604ba62667c270815bf` +in result commit `252b8c8d0cf243c4661c7aa0700f28f039afb8d2`. The frozen representation decisions are: - lossy DC: leaf bounds are authorized for dispatchable `Pg` and network `p_flows`; - single-node DC: leaf bounds are authorized for dispatchable `Pg`; +- lossy DC: leaf bounds are also authorized for storage real power and SoC, + nondispatchable real power, load-shed fraction, and HVDC from-terminal power; +- single-node DC: leaf bounds are also authorized for storage real power and + SoC, nondispatchable real power, and load-shed fraction; - AC: M14a.1 is isolated compatibility evidence only. No new AC leaf-bound migration is authorized. The existing production voltage leaf attribute is preserved, while generator and component operating boxes remain explicit; @@ -119,6 +129,12 @@ mismatched leaf arm selects explicit inequalities for that formulation/family without blocking other gates or M14b. Preliminary dirty-tree runs are diagnostic only and cannot change the production decision registry. +The authoritative run accepted all seven formulation-local pairs and qualified +all nine formulation/family decisions for leaf bounds. This result applies only +to the tested lossy-DC and single-node component boxes under SCIPY +canonicalization and CLARABEL. It does not authorize AC leaf-bound migration +and is not a comparative runtime or RSS result. + ## Delivery order 1. **Complete:** freeze typed temporal-field and variable-representation @@ -127,10 +143,10 @@ diagnostic only and cannot change the production decision registry. without calling scalar hooks `T` times. 3. **Complete:** implement compatibility publication and typed extraction without recreating a length-`T` CVXPY object list. -4. **Pre-execution implementation complete:** execute the focused component-box - matrix from a clean commit, promote its immutable record, and freeze the - resulting local decisions. -5. **Pending:** hand the completed assembly contract to M14c's vectorized +4. **Complete:** the focused component-box matrix was executed from a clean + commit, its immutable record was promoted, and all nine local decisions were + frozen. +5. **Next:** hand the completed assembly contract to M14c's vectorized lossy-DC builder. Structural tests cover time-last shapes, `T=1`, static broadcasting, interval diff --git a/plans/milestone-14-time-vectorization.md b/plans/milestone-14-time-vectorization.md index 4c615ab..1f2feb8 100644 --- a/plans/milestone-14-time-vectorization.md +++ b/plans/milestone-14-time-vectorization.md @@ -2,13 +2,13 @@ ## Status -**In progress; M14b core compatibility contract implemented.** The frozen +**In progress; M14b complete, M14c next.** The frozen legacy Case9 and Case118 scaling ladders completed, and the formulation- specific leaf-bound gate passed. The typed horizon, one-call assembly, aggregation/publication, and public-result projection slices are implemented; the reusable seven-gate component-box harness and fresh-process runner are also -implemented. A clean authoritative component-box execution and promotion -remain before the M14c handoff. +complete. The authoritative component-box record qualified all nine tested +lossy-DC and single-node decisions and freezes the assembly contract for M14c. The M14a baseline is bound to: - execution commit `1dd5e36dcae5ad9c8176b1d1202f1055acf95c03`; @@ -25,6 +25,18 @@ compatibility for `Pg`, `Qg`, and `v` but retains explicit inequalities because the isolated fixture does not retire the production lifted-DNLP and terminal- policy risk. +The immutable M14b component-box result is bound to execution commit +`028b46e2f0af16fbff90a9bc991770f0267280a5`, source fingerprint +`45e2e91e95594b3418065c256ef476c70d14f7f679d1606a71f2fc34c57ac03b`, and +promoted-record SHA-256 +`2bdf5eda5d545a49e66afd01eeca7083bd3d81d54dfb5604ba62667c270815bf`; +the result was promoted in commit +`252b8c8d0cf243c4661c7aa0700f28f039afb8d2`. +All seven formulation-local pairs passed and all nine tested component-box +decisions select leaf bounds. The result is limited to the tested lossy-DC and +single-node boxes under SCIPY canonicalization and CLARABEL; it neither +authorizes AC migration nor establishes a runtime or RSS advantage. + The Case118 annual hierarchy experiment remains paused at S4 until the annual lossy-DC outer problem passes the remaining M14 construction, canonicalization, solve, equivalence, and resource gates below. @@ -394,6 +406,12 @@ residuals, canonical structure, and solver classification. A box may remain explicit without blocking vectorization; qualification controls only its representation. +The authoritative M14b matrix completed all seven pairs and froze leaf bounds +for lossy-DC storage power/SoC, nondispatchable power, load-shed fraction, and +HVDC input power, plus single-node storage power/SoC, nondispatchable power, and +load-shed fraction. This closes M14b and opens M14c; AC retains the explicit +component-box decisions above. + The compatibility adapter must be designed and tested explicitly. It must not materialize thousands of new CVXPY objects merely to recreate the old internal list representation. If an internal/public representation must change, freeze From f5d79ed47b1070ddf94749a5a5d083891ba056d0 Mon Sep 17 00:00:00 2001 From: Bennet Meyers Date: Fri, 28 Aug 2026 16:45:24 -0700 Subject: [PATCH 27/28] Open M14c vectorized lossy-DC stage MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Promote the M14b-qualified component boxes into the typed leaf-bound registry and freeze M14c’s objective, tolerances, resource limits, execution sequence, equivalence boundaries, and big-experiment integration gate. --- CLAUDE.md | 2 +- .../m14_time_vectorization/M14B_PROTOCOL.md | 4 +- .../m14_time_vectorization/M14C_PROTOCOL.md | 192 ++++++++++++++++++ plans/milestone-14-time-vectorization.md | 41 +++- src/cvxopf/_temporal_assembly.py | 19 +- tests/test_m14b_temporal_contract.py | 13 +- 6 files changed, 244 insertions(+), 27 deletions(-) create mode 100644 experiments/m14_time_vectorization/M14C_PROTOCOL.md diff --git a/CLAUDE.md b/CLAUDE.md index f7f289c..5b42b0a 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -737,7 +737,7 @@ is present. | 11 — SOCP (convex) network model | 🔲 Future | | | 12 — Extend battery parameters: final SoC, penalty vs constraint | ✅ Complete | Storage-owned terminal equality or zero-shortfall constraints and linear/quadratic, one-/two-sided terminal costs, consistently composed across formulations. See `plans/milestone-12-storage-terminal-soc.md`. | | 13 — Extend CVXPY parameterization for problem data | 🔲 Future | Faster repeated solves of the same graph over new data | -| 14 — Time-vectorized multistep formulations | 🟧 M14b complete / M14c next | M14a's frozen legacy baseline, M14a.1's formulation-specific leaf-bound qualification, and M14b's explicit time-last assembly contract are complete. Under SCIPY canonicalization with CLARABEL, the tested lossy-DC and single-node generator, network, storage, nondispatchable, load-shedding, and lossy-DC HVDC boxes select leaf bounds; AC permits no new leaf-bound migration. M14c's vectorized lossy-DC builder remains the first formulation delivery and blocks resumption of the Case118 annual S4 outer solve. See `plans/milestone-14-time-vectorization.md` and `experiments/m14_time_vectorization/M14B_PROTOCOL.md`. | +| 14 — Time-vectorized multistep formulations | 🟧 M14c open / blocking | M14a's frozen legacy baseline, M14a.1's formulation-specific leaf-bound qualification, and M14b's explicit time-last assembly contract are complete. Under SCIPY canonicalization with CLARABEL, the tested lossy-DC and single-node generator, network, storage, nondispatchable, load-shedding, and lossy-DC HVDC boxes select leaf bounds; AC permits no new leaf-bound migration. M14c is implementing the vectorized lossy-DC builder and blocks resumption of the Case118 annual S4 outer solve. See `plans/milestone-14-time-vectorization.md`, `experiments/m14_time_vectorization/M14B_PROTOCOL.md`, and `experiments/m14_time_vectorization/M14C_PROTOCOL.md`. | | 15 — Full lossy HVDC (sign-switching converter losses) | 🔲 Future | charge/discharge-style split of `p_in`; adds fixed converter loss (`LOSS0`); enables losses in `free` and zero-straddling `band` steps; reactive-power support proposed. See `plans/milestone-15-full-lossy-hvdc.md`. | | 16 — Unify grid component model patterns | ✅ Complete | Generators, storage, nondispatchable units, and HVDC share formulation-specific injection and operating-set APIs, temporal coupling slots, and device-owned cost boundaries. Includes first-class `DispatchableGenerator`, MATPOWER fallback, stable identity for external ND/HVDC tables, and collapsed singlenode reuse. See `plans/milestone-16-unify-components.md` and `memories/M16-in-flight-record.md`. | | 17 — Hierarchical DC→AC receding-horizon dispatch | ✅ Complete | The capstone controller passes **identity-aligned SoC signposts only** (not other setpoints) from long-horizon `lossy_dc` planning into short AC-OPF windows, executes only residual-checked target-conditioned first actions, supports causal shifted initialization with audited recovery, and retains the complete plan/attempt tree. M17 fixes the validated `lossy_dc`→`ac` workflow; configurable formulations and additional layers are M21. See `plans/milestone-17-hierarchical-dc-ac.md`. | diff --git a/experiments/m14_time_vectorization/M14B_PROTOCOL.md b/experiments/m14_time_vectorization/M14B_PROTOCOL.md index 0727836..ee52501 100644 --- a/experiments/m14_time_vectorization/M14B_PROTOCOL.md +++ b/experiments/m14_time_vectorization/M14B_PROTOCOL.md @@ -146,8 +146,8 @@ and is not a comparative runtime or RSS result. 4. **Complete:** the focused component-box matrix was executed from a clean commit, its immutable record was promoted, and all nine local decisions were frozen. -5. **Next:** hand the completed assembly contract to M14c's vectorized - lossy-DC builder. +5. **Complete:** the frozen assembly contract is handed to the open M14c + vectorized lossy-DC stage. Structural tests cover time-last shapes, `T=1`, static broadcasting, interval identity alignment, boundary indexing, DCP validity of every component term, diff --git a/experiments/m14_time_vectorization/M14C_PROTOCOL.md b/experiments/m14_time_vectorization/M14C_PROTOCOL.md new file mode 100644 index 0000000..1287fbc --- /dev/null +++ b/experiments/m14_time_vectorization/M14C_PROTOCOL.md @@ -0,0 +1,192 @@ +# M14c vectorized lossy-DC protocol + +## Status and authority + +M14c is open. It implements the first production formulation on the completed +M14b time-last assembly contract and is the remaining blocker for resuming the +Case118 annual S4 outer solve. The retained stepwise/CPP formulation remains +available and remains the default; callers select the new path explicitly with +`temporal_assembly="vectorized"`. + +M14c is authorized by: + +- the immutable M14a legacy characterization; +- the M14a.1 formulation-owned bound decisions; +- the completed M14b assembly and result-projection contract; and +- `M14B_COMPONENT_BOX_RESULTS.json`, SHA-256 + `2bdf5eda5d545a49e66afd01eeca7083bd3d81d54dfb5604ba62667c270815bf`. + +The combined M14a.1/M14b registry authorizes the complete lossy-DC leaf-bound +set. M14a.1 authorizes the formulation-owned dispatchable-generation and +branch-flow boxes with authority `m14a1_qualified`. M14b authorizes the tested +storage real-power and SoC, nondispatchable real-power, load-shed-fraction, and +HVDC from-terminal-power component boxes with authority `m14b_qualified`. All +coupled constraints and equations remain explicit. No M14c result authorizes +AC or single-node migration. + +## Production formulation contract + +The vectorized lossy-DC builder constructs one CVXPY object per logical +horizon variable or expression, with time on the last axis. In particular: + +- `Pg` has shape `(n_generator, T)`; +- `p_flows` has shape `(n_branch, T)`; +- interval component variables and expressions use `(n_device, T)`; +- storage SoC uses `(n_storage, T + 1)`; and +- public inputs and results remain time first through the frozen M14b + projection registry. + +The formulation owns batched branch-flow conservation, nodal active-power +balance, branch limits, and the resistance-weighted loss proxy. It consumes +one aggregated vectorized component contribution containing affine nodal +injections, operating constraints, temporal constraints, stage-cost rates, +terminal costs, variables, expressions, and result projections. It must not +call scalar component hooks once per interval or reconstruct a length-`T` +CVXPY object list for compatibility. + +The objective remains exactly: + +```text +delta * sum_t(component_stage_cost_rate_t + dc_loss_cost_rate_t) ++ component_terminal_cost +``` + +Dispatchable generation cost is already part of the aggregated component stage +cost and is not added separately. Stage costs are integrated exactly once and +horizon costs are added exactly once. Units, device identities, storage +boundary indexing, terminal policies, HVDC sign/loss conventions, load service +and energy-not-served accounting, nondispatchable availability, and the public +result schema remain unchanged. + +Every vectorized convex build and solve records and enforces SCIPY +canonicalization. A caller-supplied conflicting backend is rejected. The +stepwise path continues to use CPP, and backend differences are explicit in +all structural and performance comparisons. + +## Verification and acceptance + +### Frozen numerical tolerances + +The M14c mathematical-equivalence gate uses an absolute tolerance of `2e-5` +and a relative tolerance of `1e-9` for objectives, declared component costs, +and uniquely determined numeric result fields. Independent physical and +accounting residuals must not exceed `1e-5`. Exact identities, shapes, schemas, +boundary indices, classifications, and provenance fields admit no tolerance. +Nonunique coordinates may differ only when both solutions independently pass +the complete feasibility, accounting, and objective gates and the field is +explicitly classified as nonunique. + +These are M14c stepwise-versus-vectorized mathematical tolerances. They do not +replace the S4 public-controller-versus-streaming seam tolerance of `1e-9` or +any frozen S4 acceptance tolerance. + +### Frozen bounded-scaling resources and stop rules + +The execution sequence is fixed. Unit, `T=1`, and short-horizon mathematical +equivalence gates run first on the M14 branch. The reviewed implementation is +then integrated into `big-experiment`. Only there does the bounded Case118 +ladder run, using the deterministic first 24, 168, and 720 hourly rows of the +frozen S4 load, reactive-load, and nondispatchable-availability inputs. Each +prefix retains the exact S4 network, device fleet and identities, one-hour +timestep, policy, solver configuration, and construction options; the frozen +terminal policy is applied at that prefix's final boundary. No separate M14 +scaling fixture is authorized. + +Each prefix runs in order in a fresh supervised worker with current child RSS +sampled every second. The limits are: + +| Horizon | Child RSS | Worker wall time | Total supervisor wall time | +|---:|---:|---:|---:| +| 24 | 16,384 MiB | 600 s | 900 s | +| 168 | 16,384 MiB | 1,800 s | 2,400 s | +| 720 | 16,384 MiB | 3,600 s | 4,500 s | + +Construction, canonicalization/solve, audit, serialization, and release phases +are retained separately where observable. RSS has priority over worker wall +time and total wall time as the primary classification when triggers coincide, +while every observed trigger is retained. Missing RSS evidence is a resource- +measurement failure. Construction failure, solver exception, certified +infeasibility, unusable primal, residual rejection, provenance mismatch, and +resource termination remain distinct classifications. + +The ordered ladder stops after the first point that is not fully accepted; later +horizons are not attempted automatically. No automatic retry, limit increase, +or backend substitution is permitted. A reviewed rerun uses a fresh output +directory and is recorded as a separate attempt. + +M14c advances only after all of the following pass: + +1. structural tests for time-last network variables, sparse operators, leaf + boxes, component aggregation, objective composition, identities, and + boundary indexing; +2. `T=1` equivalence with the existing lossy-DC single-step mathematics while + preserving multistep result axes; +3. short-horizon stepwise-versus-vectorized equivalence for objective, + component costs, complete public results, and independently reconstructed + physical and accounting residuals, allowing only documented nonunique + optimal coordinates; +4. stable infeasible, solver-failure, and unusable-primal schemas and + classifications; +5. coverage of dispatchable generation, storage terminal modes, fixed and + sheddable loads, nondispatchable generation, and conditional HVDC paths; +6. explicit SCIPY provenance on vectorized solves and CPP provenance on legacy + comparison solves; +7. the 24-, 168-, and 720-step Case118 scaling ladder within the frozen + resource limits above; and +8. strict mypy, Ruff, the complete test suite, and `git diff --check`. + +Independent audits remain authoritative for scientific acceptance. Source and +canonical object counts are characterized by representation rather than +required to match the stepwise graph. + +## Annual M14c/S4 gate + +After the branch-local unit, `T=1`, and short-horizon gates pass from a clean +committed implementation, the reviewed M14c commit is integrated into +`big-experiment`, where the tracked S4 fixture and supervisor live. The +integration checkpoint must record the exact M14c and `big-experiment` source +commits, rerun those branch-local gates, verify the unchanged S4 fixture, +policy, solver, scenario, and provenance hashes, and then run the ordered +frozen-S4 prefix ladder before annual execution. The M14 branch does not +recreate a parallel S4 fixture or supervisor. + +The first authorized 8,760-step execution then uses the exact frozen Case118 +S4 fixture, supervisor, provenance, archive, equivalence, and analysis +contract. It reuses S4's frozen limits rather than introducing a newly reviewed +envelope: 16,384 MiB child RSS, 7,200 seconds worker wall time, 10,800 seconds +total supervisor wall time, and one-second polling. One accepted execution +serves simultaneously as M14c's terminal scale gate and the candidate +authoritative S4 outer result; it is not repeated ceremonially. + +Two distinct equivalence gates apply. M14c compares the stepwise and vectorized +lossy-DC formulations for mathematical equivalence. After integration, S4 +separately compares the public hierarchical controller's retained outer plan +with the experiment streaming seam on its characterized 24-hour fixture. A +pass of either gate does not substitute for the other. + +Failure remains explicit construction, canonicalization, resource, solver, or +audit evidence and is never selectively promoted. A retry requires ordinary +review and a fresh output directory. + +## Delivery order + +1. Implement and test the vectorized lossy-DC network graph and typed build. +2. Register the production vectorized component bindings using the frozen M14b + representation decisions. +3. Enable the explicit public `temporal_assembly="vectorized"` dispatch and + preserve the stepwise default. +4. Complete structural, `T=1`, short-horizon, failure, and component-matrix + equivalence gates on the M14 branch. +5. Integrate the reviewed implementation into `big-experiment` and verify the + unchanged S4 fixture and execution contract. +6. Run the ordered 24-, 168-, and 720-hour frozen-S4 prefix ladder and freeze + its evidence. +7. Authorize the single annual M14c/S4 execution only after review of all + cheaper gates. + +## Non-goals + +M14c does not vectorize AC or single-node DC, alter OPF mathematics, choose a +temporal mode automatically, remove the stepwise path, weaken any M17/S4 audit, +or claim a runtime or RSS improvement before measurement. AC and single-node +work remains M14d. diff --git a/plans/milestone-14-time-vectorization.md b/plans/milestone-14-time-vectorization.md index 1f2feb8..ae86bc7 100644 --- a/plans/milestone-14-time-vectorization.md +++ b/plans/milestone-14-time-vectorization.md @@ -2,7 +2,7 @@ ## Status -**In progress; M14b complete, M14c next.** The frozen +**In progress; M14b complete, M14c open.** The frozen legacy Case9 and Case118 scaling ladders completed, and the formulation- specific leaf-bound gate passed. The typed horizon, one-call assembly, aggregation/publication, and public-result projection slices are implemented; @@ -409,7 +409,11 @@ representation. The authoritative M14b matrix completed all seven pairs and froze leaf bounds for lossy-DC storage power/SoC, nondispatchable power, load-shed fraction, and HVDC input power, plus single-node storage power/SoC, nondispatchable power, and -load-shed fraction. This closes M14b and opens M14c; AC retains the explicit +load-shed fraction. The registry records those component decisions with +`m14b_qualified` authority, distinct from the formulation-owned +`m14a1_qualified` dispatchable-generation and branch-flow decisions. The +combined registry, rather than M14b alone, authorizes the complete lossy-DC +leaf-bound set. This closes M14b and opens M14c; AC retains the explicit component-box decisions above. The compatibility adapter must be designed and tested explicitly. It must not @@ -433,6 +437,11 @@ reconstructs a per-step object list. ### M14c — Vectorized lossy DC +**Open.** The authoritative implementation and execution contract is frozen in +`experiments/m14_time_vectorization/M14C_PROTOCOL.md`. M14c consumes the +completed M14b representation registry and retains explicit caller selection, +the stepwise default, and formulation-specific SCIPY provenance. + Implement the annual-experiment blocker first: - branch-flow variables with shape `(n_branch, T)`; @@ -445,6 +454,17 @@ Implement the annual-experiment blocker first: - vectorized HVDC boxes, injections, costs, and supported loss semantics; and - exact preservation of the lossy-DC audit and result schema. +M14c follows one reproducible execution sequence. Unit, `T=1`, and +short-horizon stepwise/vectorized gates run on this branch. The reviewed +implementation is then integrated into `big-experiment`, which owns the S4 +fixture and supervisor. Its bounded ladder uses, in order, the deterministic +first 24, 168, and 720 hourly rows of the frozen S4 exogenous inputs while +retaining the exact S4 network, fleet, identities, timestep, policy, solver, +and construction options; the terminal policy applies at each prefix's final +boundary. The 8,760-hour run is authorized only after those post-integration +prefix gates pass. No separate pre-integration Case118 scaling fixture is part +of the authoritative ladder. + The implementation should use genuine N-dimensional expressions and sparse linear operators according to the natural algebra of each component. Replacing a left-deep Python sum with a balanced sum is a useful local correction but @@ -519,15 +539,21 @@ are true: and its separately frozen vectorized structure/dimension registry, storage identities, terminal target, and provenance hashes; 4. execution provenance records the explicit SCIPY canonicalization backend; -5. construction, canonicalization, and solve remain within a newly reviewed - memory and wall-time envelope; +5. construction, canonicalization, and solve remain within the existing frozen + S4 limits: 16,384 MiB child RSS, 7,200 seconds worker wall time, 10,800 + seconds total supervisor wall time, and one-second polling; 6. no OS memory-pressure termination occurs; 7. the independently reconstructed outer audit is accepted; and 8. execution occurs from a clean committed source with a fresh output directory. The new annual result must identify the vectorized execution commit. It is not -a continuation of any failed S4 worker. +a continuation of any failed S4 worker. Because the tracked S4 fixture and +supervisor live on `big-experiment`, the reviewed M14c implementation must +first be integrated there at an explicit checkpoint. That checkpoint records +both source commits, verifies the unchanged S4 fixture/policy/solver/scenario +hashes, and reruns the cheaper M14c gates before annual authorization; M14 does +not create a duplicate S4 execution stack on this branch. ### One annual execution, two gates @@ -538,6 +564,11 @@ launched through the exact frozen S4 supervisor, fixture, provenance, resource, archive, and analysis protocol from a clean commit containing the reviewed M14c implementation. +The M14c equivalence gate compares the stepwise and vectorized lossy-DC +mathematics. The S4 equivalence gate separately compares the public +hierarchical controller's retained outer plan with the streaming experiment +seam. Both must pass after integration; neither is evidence for the other. + That single execution serves simultaneously as the terminal M14c scaling gate and the candidate authoritative S4 outer run. If every predeclared M14c and S4 gate passes, its immutable outer artifact is promoted as the authoritative S4 diff --git a/src/cvxopf/_temporal_assembly.py b/src/cvxopf/_temporal_assembly.py index b38edc5..9fa6f51 100644 --- a/src/cvxopf/_temporal_assembly.py +++ b/src/cvxopf/_temporal_assembly.py @@ -25,6 +25,7 @@ ] BoxDecisionAuthority = Literal[ "m14a1_qualified", + "m14b_qualified", "existing_production", "pending_component_gate", "ac_explicit_policy", @@ -464,14 +465,12 @@ def _decision( return BoxRepresentationDecision(representation, authority, pending) -def _pending_decisions( +def _m14b_qualified_decisions( formulation: Formulation, families: tuple[VariableBoxFamily, ...], ) -> dict[tuple[Formulation, VariableBoxFamily], BoxRepresentationDecision]: return { - (formulation, family): _decision( - "explicit", "pending_component_gate", pending=True - ) + (formulation, family): _decision("leaf", "m14b_qualified") for family in families } @@ -496,7 +495,7 @@ def _pending_decisions( "explicit", "ac_explicit_policy" ), ("ac", VariableBoxFamily.AC_VOLTAGE): _decision("leaf", "existing_production"), - **_pending_decisions( + **_m14b_qualified_decisions( "lossy_dc", ( VariableBoxFamily.STORAGE_REAL_POWER, @@ -506,7 +505,7 @@ def _pending_decisions( VariableBoxFamily.LOAD_SHED_FRACTION, ), ), - **_pending_decisions( + **_m14b_qualified_decisions( "singlenode_dc", ( VariableBoxFamily.STORAGE_REAL_POWER, @@ -543,12 +542,8 @@ def box_representation_decision( def pending_component_box_families() -> tuple[VariableBoxFamily, ...]: """Return the component-owned box families requiring focused gates.""" - return ( - VariableBoxFamily.STORAGE_REAL_POWER, - VariableBoxFamily.STORAGE_SOC, - VariableBoxFamily.NONDISPATCHABLE_REAL_POWER, - VariableBoxFamily.HVDC_INPUT_POWER, - VariableBoxFamily.LOAD_SHED_FRACTION, + return tuple( + dict.fromkeys(family for _, family in pending_component_box_pairs()) ) diff --git a/tests/test_m14b_temporal_contract.py b/tests/test_m14b_temporal_contract.py index cabcd2e..faf6169 100644 --- a/tests/test_m14b_temporal_contract.py +++ b/tests/test_m14b_temporal_contract.py @@ -372,7 +372,7 @@ def test_existing_ac_voltage_leaf_is_not_blanket_ac_authorization(): assert active.authority == reactive.authority == "ac_explicit_policy" -def test_component_boxes_are_explicit_pending_focused_convex_gates(): +def test_m14b_qualified_component_boxes_select_leaf(): expected = { VariableBoxFamily.STORAGE_REAL_POWER, VariableBoxFamily.STORAGE_SOC, @@ -380,8 +380,6 @@ def test_component_boxes_are_explicit_pending_focused_convex_gates(): VariableBoxFamily.HVDC_INPUT_POWER, VariableBoxFamily.LOAD_SHED_FRACTION, } - assert set(pending_component_box_families()) == expected - expected_pairs = { *(("lossy_dc", family) for family in expected), *( @@ -390,12 +388,13 @@ def test_component_boxes_are_explicit_pending_focused_convex_gates(): if family is not VariableBoxFamily.HVDC_INPUT_POWER ), } - assert set(pending_component_box_pairs()) == expected_pairs + assert pending_component_box_families() == () + assert pending_component_box_pairs() == () for formulation, family in expected_pairs: decision = box_representation_decision(formulation, family) - assert decision.representation == "explicit" - assert decision.authority == "pending_component_gate" - assert decision.requires_focused_qualification + assert decision.representation == "leaf" + assert decision.authority == "m14b_qualified" + assert not decision.requires_focused_qualification def test_component_box_gates_never_authorize_ac(): From 0ef895b5e665fdb3a8fffab60292329ed22fd32b Mon Sep 17 00:00:00 2001 From: Bennet Meyers Date: Sat, 29 Aug 2026 10:52:06 -0700 Subject: [PATCH 28/28] feat(m14c): add vectorized lossy-DC assembly Implement the explicit time-last lossy-DC path with typed component bindings, qualified leaf bounds, SCIPY canonicalization, stable result and failure schemas, and static-input broadcasting without horizon-sized Python copies. Preserve the stepwise default and qualify the new path through T=1, short-horizon, full-component, physical-audit, failure-schema, and full-suite regression gates. --- src/cvxopf/_component_adapters.py | 633 +++++++++++++++++--- src/cvxopf/dc_problem.py | 347 +++++++++-- src/cvxopf/generator.py | 22 + src/cvxopf/hvdc.py | 69 ++- src/cvxopf/load.py | 25 +- src/cvxopf/problem.py | 171 ++++-- src/cvxopf/storage.py | 25 + tests/test_m14_characterization.py | 15 +- tests/test_m14c_vectorized_lossy_dc.py | 764 +++++++++++++++++++++++++ 9 files changed, 1884 insertions(+), 187 deletions(-) create mode 100644 tests/test_m14c_vectorized_lossy_dc.py diff --git a/src/cvxopf/_component_adapters.py b/src/cvxopf/_component_adapters.py index 99063f9..281b6d5 100644 --- a/src/cvxopf/_component_adapters.py +++ b/src/cvxopf/_component_adapters.py @@ -8,7 +8,7 @@ from __future__ import annotations from dataclasses import dataclass -from typing import Mapping, Sequence, cast +from typing import Literal, Mapping, Sequence, cast import cvxpy as cp import numpy as np @@ -26,8 +26,17 @@ PreparationContext, StepContext, VariableSpec, + VectorizedContext, + VectorizedModelContribution, ) from cvxopf._component_assembly import ComponentRequest +from cvxopf._temporal_assembly import ( + HorizonVariableSpec, + TemporalClass, + VariableBoxFamily, + box_representation_decision, + prepare_box_bounds, +) from cvxopf.generator import DispatchableGenerator from cvxopf.hvdc import HVDCLink from cvxopf.load import Load @@ -40,6 +49,58 @@ def _array(prepared: Mapping[str, object], key: str) -> np.ndarray: return cast(np.ndarray, prepared[key]) +def _leaf_bounds( + lower: np.ndarray, + upper: np.ndarray, + *, + native_shape: tuple[int, ...], + context: VectorizedContext, + family: VariableBoxFamily, + lower_temporal_class: TemporalClass = "static", + upper_temporal_class: TemporalClass = "static", + variable_temporal_class: Literal["interval", "boundary"] = "interval", +) -> Mapping[str, object]: + """Return validated CVXPY leaf-bound attributes for one horizon variable.""" + decision = box_representation_decision(context.formulation, family) + if decision.representation != "leaf": + raise RuntimeError( + f"{context.formulation} {family.value} is not qualified for leaf bounds" + ) + box = prepare_box_bounds( + lower, + upper, + native_shape=native_shape, + horizon_steps=context.horizon_steps, + lower_temporal_class=lower_temporal_class, + upper_temporal_class=upper_temporal_class, + variable_temporal_class=variable_temporal_class, + ) + return {"bounds": [box.lower, box.upper]} + + +def _time_major_values( + values: np.ndarray, + temporal_class: TemporalClass, + *, + horizon_steps: int, + device_count: int, + label: str, +) -> np.ndarray: + """Validate temporal provenance and expose a non-tiled time-major view.""" + source = np.asarray(values, dtype=float) + expected = ( + (device_count,) if temporal_class == "static" else (horizon_steps, device_count) + ) + if source.shape != expected: + raise ValueError( + f"{label} with temporal_class={temporal_class!r} must have shape " + f"{expected}, got {source.shape}" + ) + if temporal_class == "static": + return np.broadcast_to(source[np.newaxis, :], (horizon_steps, device_count)) + return source + + def _load_prepare( units: Sequence[Load], inputs: "LoadInputs | None", @@ -53,23 +114,29 @@ def _load_prepare( set(context.ext_bus_ids), ) if inputs is None: - p_mw = np.tile( - _array(prepared, "load_p_mw"), - (context.horizon_steps, 1), - ) - q_mvar = np.tile( - _array(prepared, "load_q_mvar"), - (context.horizon_steps, 1), - ) + p_source = _array(prepared, "load_p_mw") + q_source = _array(prepared, "load_q_mvar") + p_temporal_class: TemporalClass = "static" + q_temporal_class: TemporalClass = "static" else: - p_mw = inputs.p_mw - q_mvar = inputs.q_mvar - expected_shape = (context.horizon_steps, len(units)) - if p_mw.shape != expected_shape or q_mvar.shape != expected_shape: - raise ValueError( - "load input channels must both have shape " - f"{expected_shape}, got {p_mw.shape} and {q_mvar.shape}" - ) + p_source = inputs.p_mw + q_source = inputs.q_mvar + p_temporal_class = inputs.p_temporal_class + q_temporal_class = inputs.q_temporal_class + p_mw = _time_major_values( + p_source, + p_temporal_class, + horizon_steps=context.horizon_steps, + device_count=len(units), + label="load input channels (active)", + ) + q_mvar = _time_major_values( + q_source, + q_temporal_class, + horizon_steps=context.horizon_steps, + device_count=len(units), + label="load input channels (reactive)", + ) if not np.all(np.isfinite(p_mw)) or not np.all(np.isfinite(q_mvar)): raise ValueError("load input channels must contain only finite values") if inputs is not None and inputs.has_reactive is not None: @@ -80,11 +147,19 @@ def _load_prepare( ) prepared = dict(prepared) prepared["load_has_reactive"] = inputs.has_reactive - prepared["_load_p_mw_by_step"] = np.array(p_mw, copy=True) - prepared["_load_q_mvar_by_step"] = np.array(q_mvar, copy=True) + prepared["_load_p_mw_source"] = p_source + prepared["_load_q_mvar_source"] = q_source + prepared["_load_p_temporal_class"] = p_temporal_class + prepared["_load_q_temporal_class"] = q_temporal_class + prepared["_load_vectorized_assembly"] = ( + False if inputs is None else inputs.vectorized_assembly + ) + prepared["_load_p_mw_by_step"] = p_mw + prepared["_load_q_mvar_by_step"] = q_mvar + vectorized_preparation = cast(bool, prepared["_load_vectorized_assembly"]) prepared["_load_parameters"] = ( None - if cast(int, prepared["nsheddable"]) == 0 + if cast(int, prepared["nsheddable"]) == 0 or vectorized_preparation else load._PreparedLoadParameters.create(p_mw, q_mvar) ) return prepared @@ -94,7 +169,13 @@ def _load_metadata( prepared: Mapping[str, object], formulation: Formulation, ) -> Mapping[str, object]: - return load._build_metadata(dict(prepared)) + metadata = dict(load._build_metadata(dict(prepared))) + if cast(bool, prepared["_load_vectorized_assembly"]): + metadata["load_p_temporal_class"] = prepared["_load_p_temporal_class"] + metadata["load_q_temporal_class"] = prepared["_load_q_temporal_class"] + metadata["load_p_source_mw"] = prepared["_load_p_mw_source"] + metadata["load_q_source_mvar"] = prepared["_load_q_mvar_source"] + return metadata def _load_variable_specs( @@ -114,16 +195,10 @@ def _load_step_channels( context: StepContext, ) -> Mapping[str, cp.Expression]: """Return all load input, served, and conditional shed channels.""" - parameters = cast( - load._PreparedLoadParameters | None, prepared["_load_parameters"] - ) + parameters = cast(load._PreparedLoadParameters | None, prepared["_load_parameters"]) if parameters is None: - p_load = cp.Constant( - _array(prepared, "_load_p_mw_by_step")[context.step] - ) - q_load = cp.Constant( - _array(prepared, "_load_q_mvar_by_step")[context.step] - ) + p_load = cp.Constant(_array(prepared, "_load_p_mw_by_step")[context.step]) + q_load = cp.Constant(_array(prepared, "_load_q_mvar_by_step")[context.step]) p_eligible = cp.Constant(np.empty(0)) else: p_load = parameters.p_load_mw[context.step] @@ -173,9 +248,7 @@ def _load_operating_constraints( fraction = variables.get("load_shed_fraction") if fraction is None: return () - parameters = cast( - load._PreparedLoadParameters, prepared["_load_parameters"] - ) + parameters = cast(load._PreparedLoadParameters, prepared["_load_parameters"]) indices = _array(prepared, "sheddable_load_indices") maximum_fraction = _array(prepared, "load_max_shed_fraction")[indices] constraint_method = ( @@ -223,12 +296,8 @@ def _load_horizon( context: HorizonContext, ) -> HorizonContribution: if cast(int, prepared["nsheddable"]) == 0: - return HorizonContribution( - constraints=tuple(load.coupling_constraints()) - ) - parameters = cast( - load._PreparedLoadParameters, prepared["_load_parameters"] - ) + return HorizonContribution(constraints=tuple(load.coupling_constraints())) + parameters = cast(load._PreparedLoadParameters, prepared["_load_parameters"]) indices = _array(prepared, "sheddable_load_indices") fractions = variable_history["load_shed_fraction"] shed_by_step = [ @@ -247,7 +316,117 @@ def _load_horizon( ) -LOAD_ACTIVE = FormulationAdapter[Load]( +def _load_vectorized_variable_specs( + units: Sequence[Load], + prepared: Mapping[str, object], + context: VectorizedContext, +) -> tuple[HorizonVariableSpec, ...]: + nsheddable = cast(int, prepared["nsheddable"]) + if nsheddable == 0: + return () + indices = _array(prepared, "sheddable_load_indices") + maximum = _array(prepared, "load_max_shed_fraction")[indices] + p_temporal_class = cast(TemporalClass, prepared["_load_p_temporal_class"]) + active = ( + _array(prepared, "_load_p_mw_source")[indices] + if p_temporal_class == "static" + else _array(prepared, "_load_p_mw_by_step")[:, indices] + ) + upper = (active > 0.0).astype(float) * ( + maximum if p_temporal_class == "static" else maximum[np.newaxis, :] + ) + attributes = _leaf_bounds( + np.zeros(nsheddable), + upper, + native_shape=(nsheddable,), + context=context, + family=VariableBoxFamily.LOAD_SHED_FRACTION, + lower_temporal_class="static", + upper_temporal_class=p_temporal_class, + ) + return ( + HorizonVariableSpec( + "load_shed_fraction", + (nsheddable,), + attributes=attributes, + ), + ) + + +def _load_vectorized_assembly( + units: Sequence[Load], + prepared: Mapping[str, object], + variables: Mapping[str, cp.Variable], + context: VectorizedContext, +) -> VectorizedModelContribution: + p_values = _array(prepared, "_load_p_mw_by_step").T + q_values = _array(prepared, "_load_q_mvar_by_step").T + p_load = cp.Constant(p_values) + q_load = cp.Constant(q_values) + expressions: dict[str, cp.Expression] = { + "p_load": p_load, + "q_load": q_load, + } + fraction = variables.get("load_shed_fraction") + stage_cost_rate: cp.Expression | None = None + horizon = HorizonContribution() + if fraction is None: + p_served = p_load + expressions["p_load_served"] = p_served + else: + indices = _array(prepared, "sheddable_load_indices") + p_temporal_class = cast(TemporalClass, prepared["_load_p_temporal_class"]) + eligible_values = ( + np.maximum(_array(prepared, "_load_p_mw_source"), 0.0)[:, np.newaxis] + if p_temporal_class == "static" + else np.maximum(p_values, 0.0) + ) + channels = load.served_and_shed_expressions( + p_load, + q_load, + cp.Constant(eligible_values), + fraction, + indices, + cast(int, prepared["nload"]), + interval_axis=1, + ) + channels.pop("q_load_served", None) + channels.pop("q_load_shed", None) + p_shed = channels["p_load_shed"] + p_served = channels["p_load_served"] + costs = _array(prepared, "load_shedding_cost_per_mwh")[indices] + stage_cost_rate = load.shedding_cost_rate( + p_shed, + costs[:, np.newaxis], + interval_axis=1, + ) + ens_by_load = cp.multiply(context.delta, cp.sum(p_shed, axis=1)) + expressions.update(channels) + horizon = HorizonContribution( + expressions={ + "energy_not_served_by_load": ens_by_load, + "energy_not_served": cp.sum(ens_by_load), + } + ) + p_pu, q_pu, scale = load.dc_injections(p_served, _array(prepared, "Cload")) + return VectorizedModelContribution( + injection=InjectionContribution(p_pu, q_pu, scale), + stage_cost_rate=stage_cost_rate, + expressions=expressions, + horizon=horizon, + ) + + +LOAD_AC = FormulationAdapter[Load]( + capability=FormulationCapability.ACTIVE, + variable_specs=_load_variable_specs, + injections=_load_injections, + operating_constraints=_load_operating_constraints, + step_cost=_load_step_cost, + step_expressions=_load_step_expressions, + horizon=_load_horizon, +) +LOAD_DC = FormulationAdapter[Load]( capability=FormulationCapability.ACTIVE, variable_specs=_load_variable_specs, injections=_load_injections, @@ -255,6 +434,8 @@ def _load_horizon( step_cost=_load_step_cost, step_expressions=_load_step_expressions, horizon=_load_horizon, + vectorized_variable_specs=_load_vectorized_variable_specs, + vectorized_assembly=_load_vectorized_assembly, ) @@ -265,14 +446,19 @@ class LoadInputs: p_mw: np.ndarray q_mvar: np.ndarray has_reactive: np.ndarray | None = None + p_temporal_class: TemporalClass = "interval" + q_temporal_class: TemporalClass = "interval" + vectorized_assembly: bool = False def __post_init__(self) -> None: - object.__setattr__( - self, "p_mw", np.array(self.p_mw, dtype=float, copy=True) - ) + object.__setattr__(self, "p_mw", np.array(self.p_mw, dtype=float, copy=True)) object.__setattr__( self, "q_mvar", np.array(self.q_mvar, dtype=float, copy=True) ) + if self.p_temporal_class not in {"static", "interval"}: + raise ValueError("active load temporal class must be static or interval") + if self.q_temporal_class not in {"static", "interval"}: + raise ValueError("reactive load temporal class must be static or interval") if self.has_reactive is not None: object.__setattr__( self, @@ -286,9 +472,9 @@ def __post_init__(self) -> None: prepare=_load_prepare, metadata=_load_metadata, formulations={ - "ac": LOAD_ACTIVE, - "lossy_dc": LOAD_ACTIVE, - "singlenode_dc": LOAD_ACTIVE, + "ac": LOAD_AC, + "lossy_dc": LOAD_DC, + "singlenode_dc": LOAD_DC, }, cost_expression_name="load_shedding_cost", ) @@ -312,9 +498,7 @@ def _generator_metadata( prepared: Mapping[str, object], formulation: Formulation, ) -> Mapping[str, object]: - return generator._build_metadata( - dict(prepared), reactive=formulation == "ac" - ) + return generator._build_metadata(dict(prepared), reactive=formulation == "ac") def _generator_variable_specs( @@ -432,6 +616,45 @@ def _generator_horizon( return HorizonContribution(constraints=tuple(constraints)) +def _generator_vectorized_variable_specs( + units: Sequence[DispatchableGenerator], + prepared: Mapping[str, object], + context: VectorizedContext, +) -> tuple[HorizonVariableSpec, ...]: + ng = cast(int, prepared["ng"]) + attributes = _leaf_bounds( + _array(prepared, "Pgmin"), + _array(prepared, "Pgmax"), + native_shape=(ng,), + context=context, + family=VariableBoxFamily.DISPATCHABLE_P, + ) + return (HorizonVariableSpec("Pg", (ng,), attributes=attributes),) + + +def _generator_vectorized_assembly( + units: Sequence[DispatchableGenerator], + prepared: Mapping[str, object], + variables: Mapping[str, cp.Variable], + context: VectorizedContext, +) -> VectorizedModelContribution: + p_pu, q_pu, scale = generator.dc_injections( + list(units), + variables["Pg"], + dict(context.ext_to_int), + incidence=_array(prepared, "Cg"), + ) + cost_rate = generator.horizon_cost_rate( + _array(prepared, "gencost"), + context.base_mva * variables["Pg"], + context.horizon_steps, + ) + return VectorizedModelContribution( + injection=InjectionContribution(p_pu, q_pu, scale), + stage_cost_rate=cost_rate, + ) + + GENERATOR_AC = FormulationAdapter[DispatchableGenerator]( capability=FormulationCapability.ACTIVE, variable_specs=_generator_variable_specs, @@ -449,6 +672,8 @@ def _generator_horizon( network_constraints=_generator_network_constraints, step_cost=_generator_step_cost, horizon=_generator_horizon, + vectorized_variable_specs=_generator_vectorized_variable_specs, + vectorized_assembly=_generator_vectorized_assembly, ) GENERATOR_ADAPTER = ComponentAdapter[DispatchableGenerator, None]( name="generator", @@ -467,6 +692,8 @@ class NondispatchableInputs: """Normalized ND availability supplied to component preparation.""" available_mw: np.ndarray + temporal_class: TemporalClass = "interval" + vectorized_assembly: bool = False def __post_init__(self) -> None: object.__setattr__( @@ -474,6 +701,10 @@ def __post_init__(self) -> None: "available_mw", np.array(self.available_mw, dtype=float, copy=True), ) + if self.temporal_class not in {"static", "interval"}: + raise ValueError( + "nondispatchable temporal class must be static or interval" + ) def _nd_prepare( @@ -481,17 +712,17 @@ def _nd_prepare( inputs: NondispatchableInputs, context: PreparationContext, ) -> Mapping[str, object]: - available = inputs.available_mw - expected_shape = (context.horizon_steps, len(units)) - if available.shape != expected_shape: - raise ValueError( - "nondispatchable availability must have shape " - f"{expected_shape}, got {available.shape}" - ) + source = inputs.available_mw + available = _time_major_values( + source, + inputs.temporal_class, + horizon_steps=context.horizon_steps, + device_count=len(units), + label="nondispatchable availability", + ) if not np.all(np.isfinite(available)) or np.any(available < 0): raise ValueError( - "nondispatchable availability must contain finite, " - "nonnegative values" + "nondispatchable availability must contain finite, nonnegative values" ) prepared = nondispatchable._prepare_data( list(units), @@ -499,7 +730,10 @@ def _nd_prepare( dict(context.ext_to_int), set(context.ext_bus_ids), ) - prepared["nd_available_mw"] = np.array(available, copy=True) + prepared["nd_available_source_mw"] = source + prepared["nd_available_temporal_class"] = inputs.temporal_class + prepared["nd_vectorized_assembly"] = inputs.vectorized_assembly + prepared["nd_available_mw"] = available prepared["horizon_steps"] = context.horizon_steps prepared["is_multistep"] = context.is_multistep return prepared @@ -515,6 +749,11 @@ def _nd_metadata( metadata["nd_available"] = available else: metadata["nd_p_available"] = available[0] + if cast(bool, prepared["nd_vectorized_assembly"]): + metadata["nd_available_temporal_class"] = prepared[ + "nd_available_temporal_class" + ] + metadata["nd_available_source_mw"] = prepared["nd_available_source_mw"] return metadata @@ -593,6 +832,52 @@ def _nd_horizon( return HorizonContribution(constraints=tuple(constraints)) +def _nd_vectorized_variable_specs( + units: Sequence[NondispatchableUnit], + prepared: Mapping[str, object], + context: VectorizedContext, +) -> tuple[HorizonVariableSpec, ...]: + nnd = cast(int, prepared["nnd"]) + temporal_class = cast(TemporalClass, prepared["nd_available_temporal_class"]) + available = ( + _array(prepared, "nd_available_source_mw") + if temporal_class == "static" + else _array(prepared, "nd_available_mw") + ) + rating = _array(prepared, "nd_apparent_power_rating") + upper = np.minimum( + available, + rating if temporal_class == "static" else rating[np.newaxis, :], + ) + attributes = _leaf_bounds( + np.zeros(nnd), + upper, + native_shape=(nnd,), + context=context, + family=VariableBoxFamily.NONDISPATCHABLE_REAL_POWER, + lower_temporal_class="static", + upper_temporal_class=temporal_class, + ) + return (HorizonVariableSpec("p_nd", (nnd,), attributes=attributes),) + + +def _nd_vectorized_assembly( + units: Sequence[NondispatchableUnit], + prepared: Mapping[str, object], + variables: Mapping[str, cp.Variable], + context: VectorizedContext, +) -> VectorizedModelContribution: + p_pu, q_pu, scale = nondispatchable.dc_injections( + list(units), + variables["p_nd"], + dict(context.ext_to_int), + incidence=_array(prepared, "Cnd"), + ) + return VectorizedModelContribution( + injection=InjectionContribution(p_pu, q_pu, scale) + ) + + ND_AC = FormulationAdapter[NondispatchableUnit]( capability=FormulationCapability.ACTIVE, variable_specs=_nd_variable_specs, @@ -606,10 +891,10 @@ def _nd_horizon( injections=_nd_injections, operating_constraints=_nd_operating_constraints, horizon=_nd_horizon, + vectorized_variable_specs=_nd_vectorized_variable_specs, + vectorized_assembly=_nd_vectorized_assembly, ) -NONDISPATCHABLE_ADAPTER = ComponentAdapter[ - NondispatchableUnit, NondispatchableInputs -]( +NONDISPATCHABLE_ADAPTER = ComponentAdapter[NondispatchableUnit, NondispatchableInputs]( name="nondispatchable", prepare=_nd_prepare, metadata=_nd_metadata, @@ -722,15 +1007,81 @@ def _storage_horizon( constraints = storage.coupling_constraints( list(units), b_history, soc_history, context.delta ) - terminal_cost = storage.terminal_cost_expr( - list(units), soc_history[-1] - ) + terminal_cost = storage.terminal_cost_expr(list(units), soc_history[-1]) return HorizonContribution( constraints=tuple(constraints), terminal_cost=terminal_cost, ) +def _storage_vectorized_variable_specs( + units: Sequence[StorageUnitIdeal], + prepared: Mapping[str, object], + context: VectorizedContext, +) -> tuple[HorizonVariableSpec, ...]: + ns = cast(int, prepared["ns"]) + rating = _array(prepared, "storage_apparent_power_rating") + capacity = _array(prepared, "storage_capacity") + power_attributes = _leaf_bounds( + -rating, + rating, + native_shape=(ns,), + context=context, + family=VariableBoxFamily.STORAGE_REAL_POWER, + ) + soc_attributes = _leaf_bounds( + np.zeros(ns), + capacity, + native_shape=(ns,), + context=context, + family=VariableBoxFamily.STORAGE_SOC, + variable_temporal_class="boundary", + ) + return ( + HorizonVariableSpec("b", (ns,), attributes=power_attributes), + HorizonVariableSpec( + "soc", + (ns,), + temporal_class="boundary", + attributes=soc_attributes, + result_view="post_step_boundaries", + ), + ) + + +def _storage_vectorized_assembly( + units: Sequence[StorageUnitIdeal], + prepared: Mapping[str, object], + variables: Mapping[str, cp.Variable], + context: VectorizedContext, +) -> VectorizedModelContribution: + power = variables["b"] + soc = variables["soc"] + p_pu, q_pu, scale = storage.dc_injections( + list(units), + power, + dict(context.ext_to_int), + incidence=_array(prepared, "Cs"), + ) + constraints = storage.vectorized_coupling_constraints( + list(units), power, soc, context.delta + ) + stage_cost_rate = storage.vectorized_storage_cost_rate(list(units), power) + terminal_cost = storage.terminal_cost_expr(list(units), soc[:, -1]) + horizon_expressions = ( + {} if terminal_cost is None else {"storage_terminal_cost": terminal_cost} + ) + return VectorizedModelContribution( + injection=InjectionContribution(p_pu, q_pu, scale), + stage_cost_rate=stage_cost_rate, + horizon=HorizonContribution( + constraints=tuple(constraints), + terminal_cost=terminal_cost, + expressions=horizon_expressions, + ), + ) + + STORAGE_AC = FormulationAdapter[StorageUnitIdeal]( capability=FormulationCapability.ACTIVE, variable_specs=_storage_variable_specs, @@ -746,6 +1097,8 @@ def _storage_horizon( operating_constraints=_storage_operating_constraints, step_cost=_storage_step_cost, horizon=_storage_horizon, + vectorized_variable_specs=_storage_vectorized_variable_specs, + vectorized_assembly=_storage_vectorized_assembly, ) STORAGE_ADAPTER = ComponentAdapter[StorageUnitIdeal, None]( name="storage", @@ -765,11 +1118,15 @@ class HVDCInputs: p_min_mw: np.ndarray p_max_mw: np.ndarray + temporal_class: TemporalClass = "interval" + vectorized_assembly: bool = False def __post_init__(self) -> None: object.__setattr__( self, "p_min_mw", np.array(self.p_min_mw, dtype=float, copy=True) ) + if self.temporal_class not in {"static", "interval"}: + raise ValueError("HVDC temporal class must be static or interval") object.__setattr__( self, "p_max_mw", np.array(self.p_max_mw, dtype=float, copy=True) ) @@ -788,23 +1145,49 @@ def _hvdc_prepare( ) if inputs is None: p_min, p_max = hvdc._hvdc_static_box(list(units)) - p_min = np.tile(p_min, (context.horizon_steps, 1)) - p_max = np.tile(p_max, (context.horizon_steps, 1)) + temporal_class: TemporalClass = "static" else: p_min = inputs.p_min_mw p_max = inputs.p_max_mw - expected_shape = (context.horizon_steps, len(units)) - if p_min.shape != expected_shape or p_max.shape != expected_shape: + temporal_class = inputs.temporal_class + p_min_source = p_min + p_max_source = p_max + expected_shape = ( + (len(units),) + if temporal_class == "static" + else (context.horizon_steps, len(units)) + ) + if p_min_source.shape != expected_shape or p_max_source.shape != expected_shape: raise ValueError( "HVDC bounds must both have shape " - f"{expected_shape}, got {p_min.shape} and {p_max.shape}" + f"{expected_shape}, got {p_min_source.shape} and {p_max_source.shape}" ) + p_min = _time_major_values( + p_min_source, + temporal_class, + horizon_steps=context.horizon_steps, + device_count=len(units), + label="HVDC lower bounds", + ) + p_max = _time_major_values( + p_max_source, + temporal_class, + horizon_steps=context.horizon_steps, + device_count=len(units), + label="HVDC upper bounds", + ) if not np.all(np.isfinite(p_min)) or not np.all(np.isfinite(p_max)): raise ValueError("HVDC bounds must contain only finite values") if np.any(p_min > p_max): raise ValueError("HVDC bounds must satisfy p_min_mw <= p_max_mw") - prepared["hvdc_p_min_mw"] = np.array(p_min, copy=True) - prepared["hvdc_p_max_mw"] = np.array(p_max, copy=True) + prepared["hvdc_p_min_source_mw"] = p_min_source + prepared["hvdc_p_max_source_mw"] = p_max_source + prepared["hvdc_temporal_class"] = temporal_class + prepared["hvdc_vectorized_assembly"] = ( + False if inputs is None else inputs.vectorized_assembly + ) + prepared["hvdc_p_min_mw"] = p_min + prepared["hvdc_p_max_mw"] = p_max return prepared @@ -812,7 +1195,12 @@ def _hvdc_metadata( prepared: Mapping[str, object], formulation: Formulation, ) -> Mapping[str, object]: - return hvdc._build_metadata(dict(prepared)) + metadata = dict(hvdc._build_metadata(dict(prepared))) + if cast(bool, prepared["hvdc_vectorized_assembly"]): + metadata["hvdc_temporal_class"] = prepared["hvdc_temporal_class"] + metadata["hvdc_p_min_source_mw"] = prepared["hvdc_p_min_source_mw"] + metadata["hvdc_p_max_source_mw"] = prepared["hvdc_p_max_source_mw"] + return metadata def _hvdc_variable_specs( @@ -834,9 +1222,7 @@ def _hvdc_injections( context: StepContext, ) -> InjectionContribution: injection_method = ( - hvdc.ac_injections - if context.formulation == "ac" - else hvdc.dc_injections + hvdc.ac_injections if context.formulation == "ac" else hvdc.dc_injections ) p_pu, q_pu, inv_base_mva = injection_method( list(units), @@ -897,13 +1283,102 @@ def _hvdc_horizon( return HorizonContribution(constraints=tuple(constraints)) -HVDC_ACTIVE = FormulationAdapter[HVDCLink]( +def _hvdc_vectorized_variable_specs( + units: Sequence[HVDCLink], + prepared: Mapping[str, object], + context: VectorizedContext, +) -> tuple[HorizonVariableSpec, ...]: + count = cast(int, prepared["n_hvdc"]) + temporal_class = cast(TemporalClass, prepared["hvdc_temporal_class"]) + lower = ( + _array(prepared, "hvdc_p_min_source_mw") + if temporal_class == "static" + else _array(prepared, "hvdc_p_min_mw") + ) + upper = ( + _array(prepared, "hvdc_p_max_source_mw") + if temporal_class == "static" + else _array(prepared, "hvdc_p_max_mw") + ) + attributes = _leaf_bounds( + lower, + upper, + native_shape=(count,), + context=context, + family=VariableBoxFamily.HVDC_INPUT_POWER, + lower_temporal_class=temporal_class, + upper_temporal_class=temporal_class, + ) + return ( + HorizonVariableSpec("p_hvdc_in", (count,), attributes=attributes), + HorizonVariableSpec("p_hvdc_out", (count,)), + ) + + +def _hvdc_vectorized_coefficients( + units: Sequence[HVDCLink], + prepared: Mapping[str, object], +) -> np.ndarray: + """Select owner-defined loss branches before any static broadcast.""" + temporal_class = cast(TemporalClass, prepared["hvdc_temporal_class"]) + if temporal_class == "static": + coefficients = hvdc.loss_branch_coefficients( + list(units), + _array(prepared, "hvdc_p_min_source_mw"), + _array(prepared, "hvdc_p_max_source_mw"), + ) + return coefficients[:, np.newaxis] + return hvdc.loss_branch_coefficients( + list(units), + _array(prepared, "hvdc_p_min_mw").T, + _array(prepared, "hvdc_p_max_mw").T, + ) + + +def _hvdc_vectorized_assembly( + units: Sequence[HVDCLink], + prepared: Mapping[str, object], + variables: Mapping[str, cp.Variable], + context: VectorizedContext, +) -> VectorizedModelContribution: + p_in = variables["p_hvdc_in"] + p_out = variables["p_hvdc_out"] + p_pu, q_pu, scale = hvdc.dc_injections( + list(units), + p_in, + p_out, + dict(context.ext_to_int), + incidence=( + _array(prepared, "Ch_from"), + _array(prepared, "Ch_to"), + ), + ) + coefficients = _hvdc_vectorized_coefficients(units, prepared) + cost_rate = hvdc.hvdc_cost_expr(list(units), p_in) + return VectorizedModelContribution( + injection=InjectionContribution(p_pu, q_pu, scale), + operating_constraints=(p_out == cp.multiply(coefficients, p_in),), + stage_cost_rate=cost_rate, + ) + + +HVDC_AC = FormulationAdapter[HVDCLink]( + capability=FormulationCapability.ACTIVE, + variable_specs=_hvdc_variable_specs, + injections=_hvdc_injections, + operating_constraints=_hvdc_operating_constraints, + step_cost=_hvdc_step_cost, + horizon=_hvdc_horizon, +) +HVDC_DC = FormulationAdapter[HVDCLink]( capability=FormulationCapability.ACTIVE, variable_specs=_hvdc_variable_specs, injections=_hvdc_injections, operating_constraints=_hvdc_operating_constraints, step_cost=_hvdc_step_cost, horizon=_hvdc_horizon, + vectorized_variable_specs=_hvdc_vectorized_variable_specs, + vectorized_assembly=_hvdc_vectorized_assembly, ) HVDC_NULL = FormulationAdapter[HVDCLink]( capability=FormulationCapability.NULL, @@ -913,8 +1388,8 @@ def _hvdc_horizon( prepare=_hvdc_prepare, metadata=_hvdc_metadata, formulations={ - "ac": HVDC_ACTIVE, - "lossy_dc": HVDC_ACTIVE, + "ac": HVDC_AC, + "lossy_dc": HVDC_DC, "singlenode_dc": HVDC_NULL, }, ) diff --git a/src/cvxopf/dc_problem.py b/src/cvxopf/dc_problem.py index 0d19b05..2ae69d9 100644 --- a/src/cvxopf/dc_problem.py +++ b/src/cvxopf/dc_problem.py @@ -59,20 +59,28 @@ HorizonContext, PreparationContext, StepContext, + VectorizedContext, ) from cvxopf._component_assembly import ( PreparedComponents, aggregate_horizon_contributions, aggregate_step_contributions, + aggregate_vectorized_contributions, assemble_component_horizon, assemble_component_step, + assemble_component_vectorized, integrate_component_stage_costs, integrate_stage_cost_rates, + integrate_vectorized_component_stage_costs, + integrate_vectorized_stage_cost_rate, merge_prepared_component_data, prepare_components, publish_component_expressions, publish_component_metadata, publish_component_variables, + publish_vectorized_component_expressions, + publish_vectorized_component_variables, + vectorized_component_result_projections, ) from cvxopf._component_adapters import ( HVDCInputs, @@ -90,6 +98,14 @@ from cvxopf.hvdc import ( HVDCLink, ) +from cvxopf._temporal_assembly import ( + ResultProjectionRegistry, + ResultProjectionSpec, + VariableBoxFamily, + box_representation_decision, + merge_result_projection_registries, + prepare_box_bounds, +) if TYPE_CHECKING: from cvxopf.problem import OPFBuild @@ -98,16 +114,17 @@ # MATPOWER column indices # --------------------------------------------------------------------------- -PD = 2 -BR_R = 2 -BR_STATUS = 10 -RATE_A = 5 +PD = 2 +BR_R = 2 +BR_STATUS = 10 +RATE_A = 5 # --------------------------------------------------------------------------- # Internal helpers # --------------------------------------------------------------------------- + def _parse_dc_case( case: dict, options, @@ -118,6 +135,7 @@ def _parse_dc_case( generators: list[DispatchableGenerator] | None = None, horizon_steps: int = 1, nd_available_mw: np.ndarray | None = None, + nondispatchable_inputs: NondispatchableInputs | None = None, hvdc_inputs: HVDCInputs | None = None, load_inputs: LoadInputs | None = None, is_multistep: bool = False, @@ -136,15 +154,15 @@ def _parse_dc_case( case, ext_to_int = reindex_case_to_consecutive(case) baseMVA = float(case["baseMVA"]) - bus = case["bus"] - branch = case["branch"] - nb = bus.shape[0] - nl = branch.shape[0] + bus = case["bus"] + branch = case["branch"] + nb = bus.shape[0] + nl = branch.shape[0] - A = make_branch_node_incidence_matrix(case) + A = make_branch_node_incidence_matrix(case) # branch resistances (p.u.) - r = branch[:, BR_R].astype(float) / 1.0 # already dimensionless p.u. + r = branch[:, BR_R].astype(float) / 1.0 # already dimensionless p.u. # branch flow limits (p.u.), with sentinel substitution for rateA=0 f_max = np.zeros(nl) @@ -171,10 +189,7 @@ def _parse_dc_case( component_ext_to_int = ( ext_to_int if ext_to_int is not None - else { - int(bus_id): int(bus_id) - for bus_id in bus[:, 0] - } + else {int(bus_id): int(bus_id) for bus_id in bus[:, 0]} ) ext_bus_ids = set(component_ext_to_int.keys()) @@ -187,7 +202,7 @@ def _parse_dc_case( delta=delta, is_multistep=is_multistep, ) - if nondispatchable and nd_available_mw is None: + if nondispatchable and nd_available_mw is None and nondispatchable_inputs is None: nd_available_mw = np.array( [[unit.p_available for unit in nondispatchable]], dtype=float, @@ -203,26 +218,30 @@ def _parse_dc_case( nondispatchable_inputs=( None if not nondispatchable - else NondispatchableInputs(nd_available_mw) + else ( + nondispatchable_inputs + if nondispatchable_inputs is not None + else NondispatchableInputs(nd_available_mw) + ) ), hvdc_links=hvdc or (), hvdc_inputs=hvdc_inputs, ) components = prepare_components(requests, "lossy_dc", preparation) - load_p_mw = ( - np.asarray(components.flat_data["load_p_mw"], dtype=float) - if load_inputs is None else load_inputs.p_mw[0] - ) + load_p_mw = np.asarray(components.flat_data["_load_p_mw_by_step"], dtype=float)[0] Pd = np.asarray(components.flat_data["Cload"]) @ load_p_mw / baseMVA formulation_data = dict( - case=case, baseMVA=baseMVA, - nb=nb, nl=nl, + case=case, + baseMVA=baseMVA, + nb=nb, + nl=nl, ext_to_int=ext_to_int, _component_ext_to_int=component_ext_to_int, ext_bus_ids=ext_bus_ids, A=A, - r=r, f_max=f_max, + r=r, + f_max=f_max, Pd=Pd, loss_weight=options.loss_weight, _components=components, @@ -253,10 +272,12 @@ def _make_dc_step_constraints( def _make_dc_step_cost( component_cost_rate, - r, p_flows, loss_weight, + r, + p_flows, + loss_weight, ) -> tuple[cp.Expression, cp.Expression]: """Build the total and network-loss DC stage-cost rates.""" - L = cp.sum(cp.multiply(r, cp.square(p_flows))) + L = cp.sum(cp.multiply(r, cp.square(p_flows))) loss_cost = cp.multiply(loss_weight, L) return component_cost_rate + loss_cost, loss_cost @@ -265,6 +286,7 @@ def _make_dc_step_cost( # Public builders (called from problem.py dispatch) # --------------------------------------------------------------------------- + def _build_lossy_dc_single( case: dict, options, @@ -290,7 +312,13 @@ def _build_lossy_dc_single( ) d = _parse_dc_case( - case, options, storage, delta, nondispatchable, hvdc, generators, + case, + options, + storage, + delta, + nondispatchable, + hvdc, + generators, loads=loads, load_participates_when_empty=loads is not None, ) @@ -310,7 +338,8 @@ def _build_lossy_dc_single( constr, p_net_expr = _make_dc_step_constraints( p_flows, step_aggregate.injection.p_pu, - d["A"], d["f_max"], + d["A"], + d["f_max"], step_aggregate.operating_constraints, ) constr.extend(step_aggregate.network_constraints) @@ -318,7 +347,9 @@ def _build_lossy_dc_single( assert step_aggregate.cost is not None step_cost_rate, loss_cost_rate = _make_dc_step_cost( step_aggregate.cost, - d["r"], p_flows, d["loss_weight"], + d["r"], + p_flows, + d["loss_weight"], ) cost = integrate_stage_cost_rates([step_cost_rate], delta) component_costs = integrate_component_stage_costs( @@ -341,7 +372,7 @@ def _build_lossy_dc_single( cost = cost + horizon_aggregate.terminal_cost constr.extend(horizon_aggregate.constraints) - prob = cp.Problem(cp.Minimize(cost), constr) + prob = cp.Problem(cp.Minimize(cost), constr) variables = dict(p_flows=p_flows) variables = publish_component_variables( [step_components], @@ -350,10 +381,13 @@ def _build_lossy_dc_single( ) data = dict( - baseMVA=d["baseMVA"], nb=d["nb"], nl=d["nl"], + baseMVA=d["baseMVA"], + nb=d["nb"], + nl=d["nl"], ext_to_int=d["ext_to_int"], A=d["A"], - r=d["r"], f_max=d["f_max"], + r=d["r"], + f_max=d["f_max"], Pd=d["Pd"], loss_weight=d["loss_weight"], ) @@ -363,9 +397,7 @@ def _build_lossy_dc_single( compatibility_expressions.update(component_costs) compatibility_expressions["dc_loss_cost"] = dc_loss_cost if storage_terminal_cost is not None: - compatibility_expressions["storage_terminal_cost"] = ( - storage_terminal_cost - ) + compatibility_expressions["storage_terminal_cost"] = storage_terminal_cost expressions = publish_component_expressions( [step_aggregate], horizon_aggregate, @@ -374,8 +406,11 @@ def _build_lossy_dc_single( ) return OPFBuild( - prob=prob, variables=variables, data=data, - formulation="lossy_dc", is_convex=True, + prob=prob, + variables=variables, + data=data, + formulation="lossy_dc", + is_convex=True, expressions=expressions, ) @@ -422,9 +457,7 @@ def _build_lossy_dc_multistep( hvdc, generators, horizon_steps=T, - nd_available_mw=( - None if df_nd is None else df_nd.to_numpy(dtype=float) - ), + nd_available_mw=(None if df_nd is None else df_nd.to_numpy(dtype=float)), hvdc_inputs=( None if not hvdc @@ -440,12 +473,12 @@ def _build_lossy_dc_multistep( ) Pd_series = load_inputs.p_mw @ d["Cload"].T / d["baseMVA"] - p_flows_list = [] + p_flows_list = [] component_steps = [] step_aggregates = [] components: PreparedComponents = d["_components"] p_net_expr_list = [] - all_constr = [] + all_constr = [] step_cost_rates = [] loss_cost_rates = [] @@ -468,14 +501,17 @@ def _build_lossy_dc_multistep( step_constr, p_net_expr_t = _make_dc_step_constraints( p_flows_t, step_aggregate.injection.p_pu, - d["A"], d["f_max"], + d["A"], + d["f_max"], step_aggregate.operating_constraints, ) step_constr.extend(step_aggregate.network_constraints) assert step_aggregate.cost is not None step_cost_rate, loss_cost_rate = _make_dc_step_cost( step_aggregate.cost, - d["r"], p_flows_t, d["loss_weight"], + d["r"], + p_flows_t, + d["loss_weight"], ) all_constr.extend(step_constr) @@ -516,10 +552,13 @@ def _build_lossy_dc_multistep( ) data = dict( - baseMVA=d["baseMVA"], nb=d["nb"], nl=d["nl"], + baseMVA=d["baseMVA"], + nb=d["nb"], + nl=d["nl"], ext_to_int=d["ext_to_int"], A=d["A"], - r=d["r"], f_max=d["f_max"], + r=d["r"], + f_max=d["f_max"], loss_weight=d["loss_weight"], T=T, Pd_series=Pd_series, @@ -530,9 +569,7 @@ def _build_lossy_dc_multistep( compatibility_expressions.update(component_costs) compatibility_expressions["dc_loss_cost"] = dc_loss_cost if storage_terminal_cost is not None: - compatibility_expressions["storage_terminal_cost"] = ( - storage_terminal_cost - ) + compatibility_expressions["storage_terminal_cost"] = storage_terminal_cost expressions = publish_component_expressions( step_aggregates, horizon_aggregate, @@ -541,7 +578,217 @@ def _build_lossy_dc_multistep( ) return OPFBuild( - prob=prob, variables=variables, data=data, - formulation="lossy_dc", is_convex=True, + prob=prob, + variables=variables, + data=data, + formulation="lossy_dc", + is_convex=True, expressions=expressions, ) + + +def _build_lossy_dc_vectorized( + case: dict, + df_P: pd.DataFrame | None, + df_Q: pd.DataFrame | None, + T: int, + options, + coupling_constraints: list, + storage: list[StorageUnitIdeal] | None = None, + delta: float = 1.0, + nondispatchable: list[NondispatchableUnit] | None = None, + df_nd: pd.DataFrame | None = None, + *, + hvdc=None, + df_hvdc_min=None, + df_hvdc_max=None, + generators: list[DispatchableGenerator] | None = None, + loads: list[Load] | None = None, + load_inputs: LoadInputs, + load_participates_when_empty: bool = False, + nd_inputs: NondispatchableInputs | None = None, + hvdc_inputs: HVDCInputs | None = None, +) -> "OPFBuild": + """Build one time-last, horizon-vectorized lossy-DC problem.""" + from cvxopf.problem import OPFBuild + + del df_P, df_Q + if storage: + warnings.warn( + "Storage apparent_power_rating is applied as a real power limit " + "only for formulation='lossy_dc'. Reactive power is not modelled " + "in the DC formulation.", + UserWarning, + stacklevel=3, + ) + + d = _parse_dc_case( + case, + options, + storage, + delta, + nondispatchable, + hvdc, + generators, + horizon_steps=T, + nd_available_mw=( + None + if nd_inputs is not None or df_nd is None + else df_nd.to_numpy(dtype=float) + ), + nondispatchable_inputs=nd_inputs, + hvdc_inputs=( + hvdc_inputs + if hvdc_inputs is not None or not hvdc + else HVDCInputs( + df_hvdc_min.to_numpy(dtype=float), + df_hvdc_max.to_numpy(dtype=float), + ) + ), + load_inputs=load_inputs, + is_multistep=True, + loads=loads, + load_participates_when_empty=load_participates_when_empty, + ) + components: PreparedComponents = d["_components"] + context = VectorizedContext( + "lossy_dc", + T, + delta, + d["baseMVA"], + d["_component_ext_to_int"], + DCNetworkState(), + ) + component_contributions = assemble_component_vectorized(components, context) + component_aggregate = aggregate_vectorized_contributions(component_contributions) + component_injection = component_aggregate.model.injection.p_pu + component_cost_rate = component_aggregate.model.stage_cost_rate + if component_injection is None or component_cost_rate is None: + raise RuntimeError( + "lossy-DC vectorized assembly requires active injection and cost" + ) + + flow_decision = box_representation_decision( + "lossy_dc", VariableBoxFamily.DC_BRANCH_FLOW + ) + if flow_decision.representation != "leaf": + raise RuntimeError("lossy-DC branch flow is not qualified for leaf bounds") + flow_box = prepare_box_bounds( + -np.asarray(d["f_max"]), + np.asarray(d["f_max"]), + native_shape=(d["nl"],), + horizon_steps=T, + lower_temporal_class="static", + upper_temporal_class="static", + variable_temporal_class="interval", + ) + p_flows = cp.Variable( + (d["nl"], T), + name="p_flows", + bounds=[flow_box.lower, flow_box.upper], + ) + p_net = component_injection + loss_cost_rate = cp.multiply( + d["loss_weight"], + cp.sum( + cp.multiply( + np.asarray(d["r"])[:, np.newaxis], + cp.square(p_flows), + ), + axis=0, + ), + ) + total_cost = integrate_vectorized_stage_cost_rate( + component_cost_rate + loss_cost_rate, + delta, + ) + component_costs = integrate_vectorized_component_stage_costs( + component_contributions, + delta, + ) + dc_loss_cost = integrate_vectorized_stage_cost_rate(loss_cost_rate, delta) + terminal_cost = component_aggregate.model.horizon.terminal_cost + if terminal_cost is not None: + total_cost = total_cost + terminal_cost + + constraints = [d["A"] @ p_flows + p_net == 0] + constraints.extend(component_aggregate.model.operating_constraints) + constraints.extend(component_aggregate.model.network_constraints) + constraints.extend(component_aggregate.model.horizon.constraints) + constraints.extend(coupling_constraints) + problem = cp.Problem(cp.Minimize(total_cost), constraints) + + variables = publish_vectorized_component_variables( + component_aggregate, + {"p_flows": p_flows}, + ) + compatibility_expressions: dict[str, cp.Expression] = { + "p_net": p_net, + "dc_loss_cost": dc_loss_cost, + **component_costs, + } + expressions = publish_vectorized_component_expressions( + component_aggregate, + compatibility_expressions, + ) + load_temporal_class = components.flat_data["_load_p_temporal_class"] + if load_temporal_class == "static": + static_pd = ( + np.asarray(components.flat_data["_load_p_mw_source"]) + @ d["Cload"].T + / d["baseMVA"] + ) + pd_series = np.broadcast_to(static_pd[np.newaxis, :], (T, d["nb"])) + elif load_temporal_class == "interval": + pd_series = ( + np.asarray(components.flat_data["_load_p_mw_by_step"]) + @ d["Cload"].T + / d["baseMVA"] + ) + else: + raise RuntimeError( + "vectorized lossy-DC load temporal provenance must be static or interval" + ) + data = publish_component_metadata( + components, + { + "baseMVA": d["baseMVA"], + "nb": d["nb"], + "nl": d["nl"], + "ext_to_int": d["ext_to_int"], + "A": d["A"], + "r": d["r"], + "f_max": d["f_max"], + "loss_weight": d["loss_weight"], + "T": T, + "Pd_series": pd_series, + }, + ) + network_projections = ResultProjectionRegistry( + variables={ + "p_flows": ResultProjectionSpec( + "p_flows", (d["nl"],), (d["nl"],), "interval" + ) + }, + expressions={ + "p_net": ResultProjectionSpec("p_net", (d["nb"],), (d["nb"],), "interval"), + "dc_loss_cost": ResultProjectionSpec("dc_loss_cost", (), (), "horizon"), + }, + ) + component_projections = vectorized_component_result_projections( + component_aggregate, + integrated_component_costs=component_costs, + ) + return OPFBuild( + prob=problem, + variables=variables, + data=data, + formulation="lossy_dc", + is_convex=True, + expressions=expressions, + temporal_assembly="vectorized", + result_projections=merge_result_projection_registries( + network_projections, + component_projections, + ), + ) diff --git a/src/cvxopf/generator.py b/src/cvxopf/generator.py index f3be67a..f8f7452 100644 --- a/src/cvxopf/generator.py +++ b/src/cvxopf/generator.py @@ -673,6 +673,28 @@ def gen_cost_expr(gencost: np.ndarray, Pg_MW) -> cp.Expression: return cp.Constant(expression) +def horizon_cost_rate( + gencost: np.ndarray, + Pg_MW: cp.Expression, + horizon_steps: int, +) -> cp.Expression: + """Return one generation cost-rate value per interval. + + A fleet containing only constant polynomial costs legitimately produces a + scalar expression. Horizon assembly still requires a length-``T`` rate, + so broadcast that scalar without changing the per-interval cost meaning. + """ + expression = gen_cost_expr(gencost, Pg_MW) + if expression.is_scalar(): + return cp.multiply(np.ones(horizon_steps), expression) + if expression.shape != (horizon_steps,): + raise ValueError( + "vectorized generation cost must be scalar or horizon-shaped, " + f"got {expression.shape}" + ) + return expression + + def gen_from_matpower(gen: np.ndarray, gencost: np.ndarray) -> list: """ Build DispatchableGenerator objects from MATPOWER gen/gencost tables. diff --git a/src/cvxopf/hvdc.py b/src/cvxopf/hvdc.py index e2eba96..346cd25 100644 --- a/src/cvxopf/hvdc.py +++ b/src/cvxopf/hvdc.py @@ -244,8 +244,8 @@ def _hvdc_static_box(links: list) -> tuple: Return (p_min, p_max) as (n_hvdc,) numpy arrays in MW. Reads p_min_mw and p_max_mw directly from each HVDCLink. Used by the - single-step builder and as the tile source for multistep when - df_hvdc_min/df_hvdc_max are not provided. + single-step builder and as the static broadcast source for vectorized + multistep assembly when df_hvdc_min/df_hvdc_max are not provided. """ p_min = np.array([lnk.p_min_mw for lnk in links], dtype=float) p_max = np.array([lnk.p_max_mw for lnk in links], dtype=float) @@ -349,24 +349,9 @@ def dc_operating_constraints( step : int Time-step index used in UserWarning messages. """ - coeff_vec = np.empty(len(links)) - for k, lnk in enumerate(links): - loss_frac = lnk.loss_percent / 100.0 - if p_min_t[k] >= 0: - coeff_vec[k] = -1.0 / (1.0 - loss_frac) - elif p_max_t[k] <= 0: - coeff_vec[k] = -(1.0 - loss_frac) - else: - coeff_vec[k] = -1.0 - if loss_frac != 0.0: - warnings.warn( - f"HVDC link {k} at step {step}: box [{p_min_t[k]}, {p_max_t[k]}] " - f"straddles zero with loss_percent={lnk.loss_percent}; " - f"falling back to lossless branch (p_out = -p_in). " - f"Full sign-switching loss model deferred to Milestone 15.", - UserWarning, - stacklevel=2, - ) + coeff_vec = loss_branch_coefficients( + links, p_min_t, p_max_t, step_offset=step + ) return [ p_min_t <= p_in, @@ -375,6 +360,50 @@ def dc_operating_constraints( ] +def loss_branch_coefficients( + links: list, + p_min_mw: np.ndarray, + p_max_mw: np.ndarray, + *, + step_offset: int = 0, +) -> np.ndarray: + """Select the signed HVDC loss branch for device or time-last boxes.""" + lower = np.asarray(p_min_mw, dtype=float) + upper = np.asarray(p_max_mw, dtype=float) + if lower.shape != upper.shape or lower.ndim not in {1, 2}: + raise ValueError("HVDC loss boxes must be aligned device or time-last arrays") + if lower.shape[0] != len(links): + raise ValueError("HVDC loss-box device axis must match the link fleet") + coefficients = np.empty_like(lower) + for link_index, link in enumerate(links): + loss_fraction = link.loss_percent / 100.0 + link_lower = lower[link_index] + link_upper = upper[link_index] + positive = link_lower >= 0.0 + negative = (~positive) & (link_upper <= 0.0) + coefficients[link_index] = np.where( + positive, + -1.0 / (1.0 - loss_fraction), + np.where(negative, -(1.0 - loss_fraction), -1.0), + ) + straddling = ~(positive | negative) + if loss_fraction != 0.0 and np.any(straddling): + steps = np.flatnonzero(np.atleast_1d(straddling)) + step_offset + for step in steps: + index = 0 if lower.ndim == 1 else int(step - step_offset) + warnings.warn( + f"HVDC link {link_index} at step {int(step)}: box " + f"[{np.atleast_1d(link_lower)[index]}, " + f"{np.atleast_1d(link_upper)[index]}] straddles zero with " + f"loss_percent={link.loss_percent}; falling back to lossless " + "branch (p_out = -p_in). Full sign-switching loss model " + "deferred to Milestone 15.", + UserWarning, + stacklevel=2, + ) + return coefficients + + def ac_operating_constraints( links: list, p_in: cp.Variable, diff --git a/src/cvxopf/load.py b/src/cvxopf/load.py index 2b9ad5f..7c4abb5 100644 --- a/src/cvxopf/load.py +++ b/src/cvxopf/load.py @@ -344,8 +344,15 @@ def served_and_shed_expressions( fraction: cp.Variable | None, sheddable_indices: np.ndarray, nload: int, + *, + interval_axis: int | None = None, ) -> dict[str, cp.Expression]: - """Construct device-aligned served and conditional shedding channels.""" + """Construct device-aligned served and conditional shedding channels. + + ``interval_axis`` identifies the time axis for a horizon expression. The + device axis remains first, so the same algebra owns scalar and time-last + assembly while interval totals retain their time dimension. + """ expressions: dict[str, cp.Expression] = { "p_load": p_load_mw, "q_load": q_load_mvar, @@ -360,12 +367,17 @@ def served_and_shed_expressions( scatter[sheddable_indices, np.arange(nsheddable)] = 1.0 p_shed = cp.multiply(fraction, p_eligible_mw[sheddable_indices]) q_shed = cp.multiply(fraction, q_load_mvar[sheddable_indices]) + p_total = ( + cp.sum(p_shed) + if interval_axis is None + else cp.sum(p_shed, axis=1 - interval_axis) + ) expressions.update( { "p_load_shed": p_shed, "q_load_shed": q_shed, "load_shed_fraction": fraction, - "p_load_shed_total": cp.sum(p_shed), + "p_load_shed_total": p_total, "p_load_served": p_load_mw - scatter @ p_shed, "q_load_served": q_load_mvar - scatter @ q_shed, } @@ -376,9 +388,16 @@ def served_and_shed_expressions( def shedding_cost_rate( p_load_shed: cp.Expression, cost_per_mwh: np.ndarray, + *, + interval_axis: int | None = None, ) -> cp.Expression: """Return the linear value-of-lost-load stage-cost rate.""" - return cp.sum(cp.multiply(cost_per_mwh, p_load_shed)) + weighted = cp.multiply(cost_per_mwh, p_load_shed) + return ( + cp.sum(weighted) + if interval_axis is None + else cp.sum(weighted, axis=1 - interval_axis) + ) def coupling_constraints() -> list[cp.Constraint]: diff --git a/src/cvxopf/problem.py b/src/cvxopf/problem.py index fecf0fb..e731f91 100644 --- a/src/cvxopf/problem.py +++ b/src/cvxopf/problem.py @@ -41,7 +41,11 @@ ) from cvxopf.generator import DispatchableGenerator, _case_with_generators from cvxopf.load import Load -from cvxopf._component_adapters import LoadInputs +from cvxopf._component_adapters import ( + HVDCInputs, + LoadInputs, + NondispatchableInputs, +) from cvxopf._temporal_assembly import ResultProjectionRegistry from cvxopf.data import align_device_dataframe, load_timeseries_from_dataframe @@ -348,6 +352,12 @@ def _get_multistep_builders() -> dict[str, Callable[..., OPFBuild]]: } +def _get_vectorized_multistep_builders() -> dict[str, Callable[..., OPFBuild]]: + from cvxopf.dc_problem import _build_lossy_dc_vectorized + + return {"lossy_dc": _build_lossy_dc_vectorized} + + def _validate_temporal_delta(delta: float) -> None: """Validate the global time-step duration at the public API boundary.""" if isinstance(delta, (bool, np.bool_)) or not isinstance(delta, Real): @@ -370,6 +380,7 @@ def _normalize_multistep_load_inputs( df_load_q: pd.DataFrame | None, T: int, formulation: str, + temporal_assembly: TemporalAssembly, ) -> tuple[LoadInputs, bool]: """Select and normalize exactly one public multistep load-input mode.""" explicit = loads is not None @@ -392,7 +403,11 @@ def _normalize_multistep_load_inputs( f"T={T} but df_P has {p_pu.shape[0]} rows; they must match." ) base_mva = float(case["baseMVA"]) - return LoadInputs(p_pu * base_mva, q_pu * base_mva), False + return LoadInputs( + p_pu * base_mva, + q_pu * base_mva, + vectorized_assembly=temporal_assembly == "vectorized", + ), False if df_P is not None or df_Q is not None: raise ValueError( @@ -401,22 +416,43 @@ def _normalize_multistep_load_inputs( ) assert loads is not None if df_load_p is None: - p_mw = np.tile([unit.p_load_mw for unit in loads], (T, 1)) + p_static = np.asarray([unit.p_load_mw for unit in loads], dtype=float) + if temporal_assembly == "vectorized": + p_mw = p_static + p_temporal_class = "static" + else: + p_mw = np.tile(p_static, (T, 1)) + p_temporal_class = "interval" else: p_mw = align_device_dataframe(df_load_p, loads, T, "df_load_p") + p_temporal_class = "interval" if df_load_q is None: - q_mvar = np.tile( + q_static = np.asarray( [0.0 if unit.q_load_mvar is None else unit.q_load_mvar for unit in loads], - (T, 1), + dtype=float, ) + if temporal_assembly == "vectorized": + q_mvar = q_static + q_temporal_class = "static" + else: + q_mvar = np.tile(q_static, (T, 1)) + q_temporal_class = "interval" else: q_mvar = align_device_dataframe(df_load_q, loads, T, "df_load_q") + q_temporal_class = "interval" has_reactive = np.asarray( [unit.q_load_mvar is not None for unit in loads], dtype=bool ) if df_load_q is not None: has_reactive[:] = True - return LoadInputs(p_mw, q_mvar, has_reactive), True + return LoadInputs( + p_mw, + q_mvar, + has_reactive, + p_temporal_class=p_temporal_class, + q_temporal_class=q_temporal_class, + vectorized_assembly=temporal_assembly == "vectorized", + ), True # --------------------------------------------------------------------------- @@ -567,21 +603,21 @@ def build_opf_multistep( df_load_p : pd.DataFrame | None, optional Explicit-load active trajectories in MW. Columns must exactly match unique ``Load.device_id`` values and are aligned to device order. If - omitted, each load's static ``p_load_mw`` is tiled across the horizon. + omitted, each load's static ``p_load_mw`` is broadcast across the horizon. df_load_q : pd.DataFrame | None, optional Explicit-load reactive trajectories in MVAr with the same identity contract. May define a trajectory when static ``q_load_mvar`` is ``None``. DC formulations retain this input for reporting, warn, and do not use it in optimization. If omitted, static reactive values - (with ``None`` represented numerically as zero) are tiled. + (with ``None`` represented numerically as zero) are broadcast. T : int Number of time steps. Must equal the row count of every supplied load - trajectory; static explicit-load fallback is tiled to this length. + trajectory; static explicit-load fallback is broadcast to this length. temporal_assembly : {"stepwise", "vectorized"}, optional Temporal graph representation. ``"stepwise"`` preserves the existing - per-interval builder and remains the compatibility default. The - ``"vectorized"`` selector is reserved by M14 and is rejected until - its horizon-level implementation is available. + per-interval builder and remains the compatibility default. + ``"vectorized"`` explicitly selects the M14 time-last lossy-DC path; + other formulations reject that pairing until separately qualified. formulation : str Same options as build_opf, including "singlenode_dc" (single-node copper-plate DC dispatch; df_Q reporting-only). @@ -609,8 +645,9 @@ def build_opf_multistep( Shape (T, nnd) where nnd = len(nondispatchable). Columns must exactly match the units' unique, nonempty ``device_id`` values; arbitrary input order is aligned to device-list order. - If None and nondispatchable is not None, the p_available field - from each NondispatchableUnit is tiled across all T steps. + If None and nondispatchable is not None, each unit's ``p_available`` + is used across all T steps. The vectorized path preserves it as static + broadcast data; the stepwise path retains its historical tile. generators : list[DispatchableGenerator] | None, optional Dispatchable generators. If None, convert the case dict's ``gen``/``gencost`` tables at build time. @@ -624,11 +661,6 @@ def build_opf_multistep( options = OPFOptions() if temporal_assembly not in {"stepwise", "vectorized"}: raise ValueError("temporal_assembly must be 'stepwise' or 'vectorized'") - if temporal_assembly == "vectorized": - raise NotImplementedError( - "temporal_assembly='vectorized' is reserved for the M14b " - "horizon-level implementation" - ) if coupling_constraints is None: coupling_constraints = [] if generators is not None and len(generators) == 0: @@ -644,9 +676,22 @@ def build_opf_multistep( raise ValueError( f"Unknown formulation '{formulation}'. Supported: {sorted(builders.keys())}" ) + if temporal_assembly == "vectorized" and formulation != "lossy_dc": + raise NotImplementedError( + "temporal_assembly='vectorized' is currently supported only for " + "formulation='lossy_dc'" + ) load_inputs, explicit_load_mode = _normalize_multistep_load_inputs( - case, df_P, df_Q, loads, df_load_p, df_load_q, T, formulation + case, + df_P, + df_Q, + loads, + df_load_p, + df_load_q, + T, + formulation, + temporal_assembly, ) if formulation in {"lossy_dc", "singlenode_dc"} and ( (not explicit_load_mode and df_Q is not None) @@ -661,21 +706,43 @@ def build_opf_multistep( stacklevel=2, ) + nd_inputs: NondispatchableInputs | None = None # Normalize ND availability once at the public API boundary. if nondispatchable: if df_nd is None: + fallback_action = ( + "using static p_available from each NondispatchableUnit " + "across all T steps." + if temporal_assembly == "vectorized" + else "tiling p_available from each NondispatchableUnit " + "across all T steps." + ) warnings.warn( - "df_nd not provided; tiling p_available from each " - "NondispatchableUnit across all T steps.", + f"df_nd not provided; {fallback_action}", UserWarning, stacklevel=2, ) - nd_available = np.tile( - [unit.p_available for unit in nondispatchable], (T, 1) + nd_available = np.asarray( + [unit.p_available for unit in nondispatchable], dtype=float ) + nd_temporal_class = "static" else: nd_available = _parse_nd_timeseries(df_nd, T, nondispatchable) - df_nd = pd.DataFrame(nd_available) + nd_temporal_class = "interval" + if temporal_assembly == "vectorized": + nd_inputs = NondispatchableInputs( + nd_available, + temporal_class=nd_temporal_class, + vectorized_assembly=True, + ) + df_nd = None + else: + if nd_temporal_class == "static": + nd_available = np.broadcast_to( + nd_available[np.newaxis, :], + (T, len(nondispatchable)), + ) + df_nd = pd.DataFrame(nd_available) elif df_nd is not None: warnings.warn( "df_nd is ignored because no nondispatchable units were provided.", @@ -684,18 +751,35 @@ def build_opf_multistep( ) df_nd = None - # HVDC frame handling: tile static box or validate provided frames. + hvdc_inputs: HVDCInputs | None = None + # HVDC frame handling: preserve static boxes or validate provided frames. if hvdc and formulation != "singlenode_dc": if df_hvdc_min is None and df_hvdc_max is None: + fallback_action = ( + "using the static box from HVDCLink bounds across all T steps." + if temporal_assembly == "vectorized" + else "tiling static box from HVDCLink bounds across all T steps." + ) warnings.warn( - "df_hvdc_min/df_hvdc_max not provided; tiling static box from " - "HVDCLink bounds across all T steps.", + f"df_hvdc_min/df_hvdc_max not provided; {fallback_action}", UserWarning, stacklevel=2, ) p_min_static, p_max_static = _hvdc_static_box(hvdc) - df_hvdc_min = pd.DataFrame(np.tile(p_min_static, (T, 1))) - df_hvdc_max = pd.DataFrame(np.tile(p_max_static, (T, 1))) + if temporal_assembly == "vectorized": + hvdc_inputs = HVDCInputs( + p_min_static, + p_max_static, + temporal_class="static", + vectorized_assembly=True, + ) + else: + df_hvdc_min = pd.DataFrame( + np.broadcast_to(p_min_static[np.newaxis, :], (T, len(hvdc))) + ) + df_hvdc_max = pd.DataFrame( + np.broadcast_to(p_max_static[np.newaxis, :], (T, len(hvdc))) + ) elif df_hvdc_min is None or df_hvdc_max is None: raise ValueError("df_hvdc_min and df_hvdc_max must be provided together.") else: @@ -710,8 +794,18 @@ def build_opf_multistep( f"box invariant p_min <= p_max violated." ) aligned_ids = [link.device_id for link in hvdc] - df_hvdc_min = pd.DataFrame(mins, columns=aligned_ids) - df_hvdc_max = pd.DataFrame(maxs, columns=aligned_ids) + if temporal_assembly == "vectorized": + hvdc_inputs = HVDCInputs( + mins, + maxs, + temporal_class="interval", + vectorized_assembly=True, + ) + df_hvdc_min = None + df_hvdc_max = None + else: + df_hvdc_min = pd.DataFrame(mins, columns=aligned_ids) + df_hvdc_max = pd.DataFrame(maxs, columns=aligned_ids) elif not hvdc and (df_hvdc_min is not None or df_hvdc_max is not None): warnings.warn( "df_hvdc_min/df_hvdc_max are ignored because no HVDC links were provided.", @@ -724,8 +818,18 @@ def build_opf_multistep( normalized_case = ( _case_with_generators(case, generators) if generators is not None else case ) + selected_builders = ( + _get_vectorized_multistep_builders() + if temporal_assembly == "vectorized" + else builders + ) + vectorized_inputs = ( + {"nd_inputs": nd_inputs, "hvdc_inputs": hvdc_inputs} + if temporal_assembly == "vectorized" + else {} + ) return _finalize_temporal_assembly( - builders[formulation]( + selected_builders[formulation]( normalized_case, df_P, df_Q, @@ -743,6 +847,7 @@ def build_opf_multistep( loads=loads, load_inputs=load_inputs, load_participates_when_empty=explicit_load_mode, + **vectorized_inputs, ), temporal_assembly, ) diff --git a/src/cvxopf/storage.py b/src/cvxopf/storage.py index 09f217c..0e5838d 100644 --- a/src/cvxopf/storage.py +++ b/src/cvxopf/storage.py @@ -570,12 +570,37 @@ def coupling_constraints( return constraints +def vectorized_coupling_constraints( + storage_units: list, + power: cp.Variable, + soc: cp.Variable, + delta: float, +) -> list[cp.Constraint]: + """Time-last ideal-storage recurrence and terminal policy.""" + initial_soc = _storage_static_data(storage_units)["storage_initial_soc"] + constraints: list[cp.Constraint] = [ + soc[:, 0] == initial_soc, + soc[:, 1:] == soc[:, :-1] - cp.multiply(float(delta), power), + ] + constraints += _terminal_soc_constraints(storage_units, soc[:, -1]) + return constraints + + def storage_cost_expr(storage_units: list, b: cp.Variable) -> cp.Expression: """L1 cycling cost rate; integration is owned by shared assembly.""" weights = _storage_static_data(storage_units)["storage_aging_weight"] return cp.sum(cp.multiply(weights, cp.abs(b))) +def vectorized_storage_cost_rate( + storage_units: list, + power: cp.Variable, +) -> cp.Expression: + """Return the time-last L1 cycling cost rate for every interval.""" + weights = _storage_static_data(storage_units)["storage_aging_weight"] + return cp.sum(cp.multiply(weights[:, np.newaxis], cp.abs(power)), axis=0) + + def terminal_cost_expr( storage_units: list, terminal_soc: cp.Variable, diff --git a/tests/test_m14_characterization.py b/tests/test_m14_characterization.py index d80fa2f..de30bdf 100644 --- a/tests/test_m14_characterization.py +++ b/tests/test_m14_characterization.py @@ -90,7 +90,7 @@ def test_stepwise_source_graph_baseline(formulation, expected): assert _digest(record) == SOURCE_GRAPH_DIGESTS[formulation] -def test_temporal_selector_is_closed_and_vectorized_is_reserved(): +def test_temporal_selector_is_closed_and_vectorized_scope_is_explicit(): active, reactive = _frames(1) with pytest.raises(ValueError, match="temporal_assembly"): build_opf_multistep( @@ -100,7 +100,7 @@ def test_temporal_selector_is_closed_and_vectorized_is_reserved(): T=1, temporal_assembly="other", # type: ignore[arg-type] ) - with pytest.raises(NotImplementedError, match="M14b"): + with pytest.raises(NotImplementedError, match="only.*lossy_dc"): build_opf_multistep( case9(), active, @@ -109,6 +109,17 @@ def test_temporal_selector_is_closed_and_vectorized_is_reserved(): temporal_assembly="vectorized", ) + build = build_opf_multistep( + case9(), + active, + reactive, + T=1, + formulation="lossy_dc", + temporal_assembly="vectorized", + ) + assert build.temporal_assembly == "vectorized" + assert build.canonicalization_backend == "SCIPY" + def test_single_step_build_records_stepwise_provenance(): build = build_opf(case9(), formulation="lossy_dc") diff --git a/tests/test_m14c_vectorized_lossy_dc.py b/tests/test_m14c_vectorized_lossy_dc.py new file mode 100644 index 0000000..9a54908 --- /dev/null +++ b/tests/test_m14c_vectorized_lossy_dc.py @@ -0,0 +1,764 @@ +"""Branch-local gates for the M14c vectorized lossy-DC formulation.""" + +from __future__ import annotations + +from contextlib import nullcontext +from typing import Any +import warnings + +import cvxpy as cp +import numpy as np +import pandas as pd +import pytest + +import cvxopf.hvdc as hvdc_module +import cvxopf.load as load_module +from cvxopf import ( + NondispatchableUnit, + StorageUnitIdeal, + build_opf, + build_opf_multistep, + extract_results, +) +from cvxopf.generator import gen_from_matpower +from cvxopf.hvdc import HVDCLink +from cvxopf.load import Load +from cvxopf.testcases import case9 + + +ATOL = 2e-5 +RTOL = 1e-9 + + +def _legacy_frames(steps: int) -> tuple[pd.DataFrame, pd.DataFrame]: + case = case9() + multipliers = np.linspace(0.9, 1.1, steps) + return ( + pd.DataFrame(multipliers[:, None] * case["bus"][:, 2]), + pd.DataFrame(multipliers[:, None] * case["bus"][:, 3]), + ) + + +def _build_pair(steps: int, **kwargs: Any): + active, reactive = _legacy_frames(steps) + builds = [] + for assembly in ("stepwise", "vectorized"): + with warnings.catch_warnings(): + warnings.simplefilter("ignore", UserWarning) + builds.append( + build_opf_multistep( + case9(), + active, + reactive, + T=steps, + formulation="lossy_dc", + temporal_assembly=assembly, + **kwargs, + ) + ) + return tuple(builds) + + +def _solve(build): + build.solve(tol_gap_abs=1e-10, tol_gap_rel=1e-10, tol_feas=1e-10) + return extract_results(build) + + +def _assert_numeric_equal(left: object, right: object) -> None: + left_array = np.asarray(left) + right_array = np.asarray(right) + assert left_array.shape == right_array.shape + if np.issubdtype(left_array.dtype, np.number): + np.testing.assert_allclose( + left_array.astype(float), + right_array.astype(float), + atol=ATOL, + rtol=RTOL, + equal_nan=True, + ) + else: + np.testing.assert_array_equal(left_array, right_array) + + +def _assert_complete_results_equal( + stepwise: dict[str, Any], vectorized: dict[str, Any] +) -> None: + assert stepwise.keys() == vectorized.keys() + for name in stepwise: + # Zero-resistance branch cycles make individual lossy-DC branch flows + # genuinely nonunique. Both representations are audited independently. + if name == "p_flows": + continue + left = stepwise[name] + right = vectorized[name] + if left is None or right is None: + assert left is right, name + elif name == "status": + assert left == right + else: + _assert_numeric_equal(left, right) + + +def _maximum_balance_residual(build, results: dict[str, Any]) -> float: + flows = np.asarray(results["p_flows"], dtype=float) / build.data["baseMVA"] + injection = np.asarray(results["p_net"], dtype=float) / build.data["baseMVA"] + return float(np.max(np.abs(flows @ build.data["A"].T + injection))) + + +def _assert_branch_limits(build, results: dict[str, Any]) -> None: + flows = np.abs(np.asarray(results["p_flows"], dtype=float)) + ratings = np.asarray(build.data["f_max"], dtype=float) * build.data["baseMVA"] + assert np.all(flows <= ratings[np.newaxis, :] + 1e-5) + + +def _polynomial_generation_cost(gencost: np.ndarray, pg_mw: np.ndarray) -> float: + total = 0.0 + for generator_index, row in enumerate(gencost): + assert int(row[0]) == 2 + count = int(row[3]) + total += float( + np.sum(np.polyval(row[4 : 4 + count], pg_mw[:, generator_index])) + ) + return total + + +def test_vectorized_network_uses_time_last_objects_leaf_bounds_and_scipy(): + stepwise, vectorized = _build_pair(4) + + assert vectorized.temporal_assembly == "vectorized" + assert vectorized.canonicalization_backend == "SCIPY" + assert vectorized.variables["p_flows"].shape == (9, 4) + assert vectorized.variables["Pg"].shape == (3, 4) + assert vectorized.expressions["p_net"].shape == (9, 4) + assert vectorized.prob.is_dcp() + assert vectorized.variables["p_flows"].attributes["bounds"] is not None + assert vectorized.variables["Pg"].attributes["bounds"] is not None + assert len(vectorized.prob.variables()) < len(stepwise.prob.variables()) + assert len(vectorized.prob.constraints) < len(stepwise.prob.constraints) + + +def test_vectorized_t1_matches_single_step_and_keeps_time_axis(): + case = case9() + single = build_opf(case, formulation="lossy_dc") + active = pd.DataFrame([case["bus"][:, 2]]) + reactive = pd.DataFrame([case["bus"][:, 3]]) + with pytest.warns(UserWarning, match="reactive power is not used"): + vectorized = build_opf_multistep( + case, + active, + reactive, + T=1, + formulation="lossy_dc", + temporal_assembly="vectorized", + ) + + single_results = _solve(single) + vector_results = _solve(vectorized) + assert vector_results["Pg"].shape == (1, 3) + assert vector_results["p_flows"].shape == (1, 9) + assert vector_results["p_net"].shape == (1, 9) + _assert_numeric_equal(single_results["objective"], vector_results["objective"]) + for name in ("Pg", "p_net", "p_load", "q_load"): + _assert_numeric_equal(single_results[name], vector_results[name][0]) + assert _maximum_balance_residual(vectorized, vector_results) <= 1e-5 + + +def test_short_horizon_complete_results_and_physical_balance_match(): + stepwise, vectorized = _build_pair(3) + step_results = _solve(stepwise) + vector_results = _solve(vectorized) + + _assert_complete_results_equal(step_results, vector_results) + assert _maximum_balance_residual(stepwise, step_results) <= 1e-5 + assert _maximum_balance_residual(vectorized, vector_results) <= 1e-5 + _assert_branch_limits(stepwise, step_results) + _assert_branch_limits(vectorized, vector_results) + + +def test_constant_only_generator_cost_is_broadcast_over_horizon(): + generators = gen_from_matpower(case9()["gen"], case9()["gencost"]) + for index, unit in enumerate(generators): + unit.cost_type = "polynomial" + unit.cost_coeffs = (float(index + 1),) + unit.cost_points = None + delta = 0.5 + stepwise, vectorized = _build_pair(3, generators=generators, delta=delta) + step_results = _solve(stepwise) + vector_results = _solve(vectorized) + + _assert_complete_results_equal(step_results, vector_results) + expected_constant_cost = delta * 3 * sum(range(1, len(generators) + 1)) + assert float(vectorized.expressions["generator_cost"].value) == pytest.approx( + expected_constant_cost, + abs=1e-8, + ) + + +def test_static_fallbacks_avoid_horizon_owned_parameters_and_constants(monkeypatch): + steps = 100 + loads = [ + Load( + bus=5, + p_load_mw=90.0, + q_load_mvar=30.0, + device_id="load", + shedding_cost_per_mwh=1_000.0, + max_shed_fraction=0.2, + ) + ] + renewable = [ + NondispatchableUnit( + bus=8, + p_available=20.0, + apparent_power_rating=25.0, + device_id="renewable", + ) + ] + links = [ + HVDCLink( + from_bus=4, + to_bus=9, + p_min_mw=0.0, + p_max_mw=10.0, + loss_percent=2.0, + device_id="hvdc", + ) + ] + observed_hvdc_box_shapes: list[tuple[tuple[int, ...], tuple[int, ...]]] = [] + observed_load_eligible: list[tuple[tuple[int, ...], bool]] = [] + observed_load_cost_shapes: list[tuple[int, ...]] = [] + original_coefficients = hvdc_module.loss_branch_coefficients + original_load_channels = load_module.served_and_shed_expressions + original_load_cost = load_module.shedding_cost_rate + + def record_coefficient_inputs(links, lower, upper, **kwargs): + observed_hvdc_box_shapes.append( + (np.asarray(lower).shape, np.asarray(upper).shape) + ) + return original_coefficients(links, lower, upper, **kwargs) + + def reject_stepwise_parameters(*_args, **_kwargs): + raise AssertionError("vectorized load preparation created stepwise parameters") + + def record_load_channels( + p_load_mw, + q_load_mvar, + p_eligible_mw, + fraction, + sheddable_indices, + nload, + **kwargs, + ): + eligible = np.asarray(p_eligible_mw.value) + observed_load_eligible.append((eligible.shape, eligible.flags.owndata)) + return original_load_channels( + p_load_mw, + q_load_mvar, + p_eligible_mw, + fraction, + sheddable_indices, + nload, + **kwargs, + ) + + def record_load_cost(p_load_shed, cost_per_mwh, **kwargs): + observed_load_cost_shapes.append(np.asarray(cost_per_mwh).shape) + return original_load_cost(p_load_shed, cost_per_mwh, **kwargs) + + monkeypatch.setattr( + hvdc_module, "loss_branch_coefficients", record_coefficient_inputs + ) + monkeypatch.setattr( + load_module._PreparedLoadParameters, + "create", + reject_stepwise_parameters, + ) + monkeypatch.setattr( + load_module, + "served_and_shed_expressions", + record_load_channels, + ) + monkeypatch.setattr(load_module, "shedding_cost_rate", record_load_cost) + with warnings.catch_warnings(): + warnings.simplefilter("ignore", UserWarning) + build = build_opf_multistep( + case9(), + T=steps, + formulation="lossy_dc", + temporal_assembly="vectorized", + loads=loads, + nondispatchable=renewable, + hvdc=links, + ) + + assert build.data["load_p_temporal_class"] == "static" + assert build.data["load_q_temporal_class"] == "static" + assert build.data["nd_available_temporal_class"] == "static" + assert build.data["hvdc_temporal_class"] == "static" + assert np.asarray(build.data["load_p_source_mw"]).shape == (1,) + assert np.asarray(build.data["nd_available_source_mw"]).shape == (1,) + assert np.asarray(build.data["hvdc_p_min_source_mw"]).shape == (1,) + assert not np.asarray(build.data["nd_available"]).flags.owndata + expected_static_pd = ( + np.asarray(build.data["load_p_source_mw"]) + @ np.asarray(build.data["Cload"]).T + / float(build.data["baseMVA"]) + ) + pd_series = np.asarray(build.data["Pd_series"]) + np.testing.assert_allclose( + pd_series, + np.broadcast_to(expected_static_pd[np.newaxis, :], pd_series.shape), + ) + assert pd_series.shape == (steps, int(build.data["nb"])) + assert not pd_series.flags.owndata + assert pd_series.strides[0] == 0 + assert observed_hvdc_box_shapes == [((1,), (1,))] + assert observed_load_eligible == [((1, 1), False)] + assert observed_load_cost_shapes == [(1, 1)] + assert {parameter.name() for parameter in build.prob.parameters()}.isdisjoint( + { + "load_p_mw", + "load_p_eligible_mw", + "load_eligibility_mask", + "load_q_mvar", + } + ) + assert np.shares_memory( + np.asarray(build.expressions["p_load"].value), + np.asarray(build.data["load_p_source_mw"]), + ) + assert np.shares_memory( + np.asarray(build.expressions["q_load"].value), + np.asarray(build.data["load_q_source_mvar"]), + ) + for name in ("load_shed_fraction", "p_nd", "p_hvdc_in"): + bounds = build.variables[name].attributes["bounds"] + assert bounds is not None + assert all(not np.asarray(face).flags.owndata for face in bounds) + + +def _component_inputs(steps: int) -> dict[str, Any]: + loads = [ + Load( + bus=5, + p_load_mw=90.0, + q_load_mvar=30.0, + device_id="load-5", + shedding_cost_per_mwh=1_000.0, + max_shed_fraction=0.2, + ), + Load( + bus=7, + p_load_mw=100.0, + q_load_mvar=35.0, + device_id="load-7", + ), + ] + storage = [ + StorageUnitIdeal( + bus=6, + apparent_power_rating=20.0, + capacity=50.0, + initial_soc=25.0, + aging_weight=0.01, + terminal_soc=25.0, + terminal_constraint="equality", + device_id="storage-6", + ) + ] + nondispatchable = [ + NondispatchableUnit( + bus=8, + p_available=20.0, + apparent_power_rating=25.0, + device_id="renewable-8", + ) + ] + links = [ + HVDCLink( + from_bus=4, + to_bus=9, + p_min_mw=0.0, + p_max_mw=10.0, + loss_percent=2.0, + cost_coeffs=(0.0, 0.1, 0.0), + device_id="hvdc-4-9", + ) + ] + return { + "loads": loads, + "df_load_p": pd.DataFrame( + np.column_stack( + [np.linspace(80.0, 95.0, steps), np.linspace(110.0, 90.0, steps)] + ), + columns=["load-5", "load-7"], + ), + "df_load_q": pd.DataFrame( + np.tile([30.0, 35.0], (steps, 1)), + columns=["load-5", "load-7"], + ), + "storage": storage, + "nondispatchable": nondispatchable, + "df_nd": pd.DataFrame( + np.resize(np.array([30.0, 0.0, 10.0]), steps), + columns=["renewable-8"], + ), + "hvdc": links, + "df_hvdc_min": pd.DataFrame(np.zeros(steps), columns=["hvdc-4-9"]), + "df_hvdc_max": pd.DataFrame( + np.linspace(10.0, 6.0, steps), columns=["hvdc-4-9"] + ), + } + + +def test_full_component_matrix_matches_complete_public_contract(): + steps = 3 + delta = 0.5 + kwargs = _component_inputs(steps) + builds = [] + for assembly in ("stepwise", "vectorized"): + with warnings.catch_warnings(): + warnings.simplefilter("ignore", UserWarning) + builds.append( + build_opf_multistep( + case9(), + T=steps, + formulation="lossy_dc", + temporal_assembly=assembly, + delta=delta, + **kwargs, + ) + ) + stepwise, vectorized = builds + step_results = _solve(stepwise) + vector_results = _solve(vectorized) + + _assert_complete_results_equal(step_results, vector_results) + expected_interval_pd = ( + kwargs["df_load_p"].to_numpy(dtype=float) + @ np.asarray(vectorized.data["Cload"]).T + / float(vectorized.data["baseMVA"]) + ) + interval_pd = np.asarray(vectorized.data["Pd_series"]) + np.testing.assert_allclose(interval_pd, expected_interval_pd) + assert vectorized.data["load_p_temporal_class"] == "interval" + assert interval_pd.flags.owndata + pg = np.asarray(vector_results["Pg"], dtype=float) + power = np.asarray(vector_results["b"], dtype=float) + flows_pu = ( + np.asarray(vector_results["p_flows"], dtype=float) / vectorized.data["baseMVA"] + ) + p_shed = np.asarray(vector_results["p_load_shed"], dtype=float) + p_hvdc = np.asarray(vector_results["p_hvdc_in"], dtype=float) + generation_cost = delta * _polynomial_generation_cost( + np.asarray(vectorized.data["gencost"], dtype=float), pg + ) + storage_cost = delta * float( + np.sum( + np.asarray(vectorized.data["storage_aging_weight"], dtype=float) + * np.sum(np.abs(power), axis=0) + ) + ) + sheddable = np.asarray(vectorized.data["sheddable_load_indices"], dtype=int) + shedding_cost = delta * float( + np.sum( + p_shed + * np.asarray(vectorized.data["load_shedding_cost_per_mwh"], dtype=float)[ + sheddable + ] + ) + ) + hvdc_cost = 0.0 + for link_index, link in enumerate(kwargs["hvdc"]): + c0, c1, c2 = link.cost_coeffs + hvdc_cost += delta * float( + np.sum( + c0 + + c1 * np.abs(p_hvdc[:, link_index]) + + c2 * p_hvdc[:, link_index] ** 2 + ) + ) + dc_loss_cost = delta * float( + vectorized.data["loss_weight"] + * np.sum(np.asarray(vectorized.data["r"]) * np.sum(flows_pu**2, axis=0)) + ) + reconstructed_objective = ( + generation_cost + storage_cost + shedding_cost + hvdc_cost + dc_loss_cost + ) + assert float(vector_results["objective"]) == pytest.approx( + reconstructed_objective, + abs=1e-5, + ) + assert _maximum_balance_residual(vectorized, vector_results) <= 1e-5 + _assert_branch_limits(vectorized, vector_results) + soc = np.asarray(vector_results["soc"], dtype=float) + initial = np.asarray(vectorized.data["storage_initial_soc"], dtype=float) + predecessor = np.vstack([initial, soc[:-1]]) + np.testing.assert_allclose(soc, predecessor - delta * power, atol=1e-5) + np.testing.assert_allclose(soc[-1], [25.0], atol=1e-5) + rating = np.asarray(vectorized.data["storage_apparent_power_rating"]) + capacity = np.asarray(vectorized.data["storage_capacity"]) + assert np.all(np.abs(power) <= rating[np.newaxis, :] + 1e-5) + assert np.all(soc >= -1e-5) + assert np.all(soc <= capacity[np.newaxis, :] + 1e-5) + assert np.min(vector_results["curtailment"]) >= -1e-5 + availability = kwargs["df_nd"].to_numpy(dtype=float) + nd_rating = np.asarray(vectorized.data["nd_apparent_power_rating"], dtype=float) + p_nd = np.asarray(vector_results["p_nd"], dtype=float) + assert np.all(p_nd >= -1e-5) + assert np.all(p_nd <= np.minimum(availability, nd_rating) + 1e-5) + np.testing.assert_allclose( + vector_results["curtailment"], availability - p_nd, atol=1e-5 + ) + assert np.min(vector_results["hvdc_loss"]) >= -1e-5 + hvdc_lower = kwargs["df_hvdc_min"].to_numpy(dtype=float) + hvdc_upper = kwargs["df_hvdc_max"].to_numpy(dtype=float) + assert np.all(p_hvdc >= hvdc_lower - 1e-5) + assert np.all(p_hvdc <= hvdc_upper + 1e-5) + coefficient = -1.0 / (1.0 - kwargs["hvdc"][0].loss_percent / 100.0) + np.testing.assert_allclose( + vector_results["p_hvdc_out"], coefficient * p_hvdc, atol=1e-5 + ) + case = case9() + assert np.all(pg >= case["gen"][:, 9] - 1e-5) + assert np.all(pg <= case["gen"][:, 8] + 1e-5) + fractions = np.asarray(vector_results["load_shed_fraction"], dtype=float) + max_fraction = np.asarray(vectorized.data["load_max_shed_fraction"])[sheddable] + assert np.all(fractions >= -1e-5) + assert np.all(fractions <= max_fraction + 1e-5) + reconstructed_load = np.asarray(vector_results["p_load_served"], dtype=float).copy() + reconstructed_load[:, 0] += np.asarray(vector_results["p_load_shed"], dtype=float)[ + :, 0 + ] + np.testing.assert_allclose(reconstructed_load, vector_results["p_load"], atol=1e-5) + expected_ens_by_load = delta * np.sum(p_shed, axis=0) + np.testing.assert_allclose( + vector_results["energy_not_served_by_load"], + expected_ens_by_load, + atol=1e-5, + ) + assert float(vector_results["energy_not_served"]) == pytest.approx( + float(np.sum(expected_ens_by_load)), + abs=1e-5, + ) + + +@pytest.mark.parametrize( + ("terminal_constraint", "terminal_cost", "terminal_weight"), + [ + ("equality", None, None), + ("shortfall", None, None), + (None, "quadratic", 2.0), + ], +) +def test_storage_terminal_modes_match( + terminal_constraint: str | None, + terminal_cost: str | None, + terminal_weight: float | None, +): + delta = 0.5 + storage = [ + StorageUnitIdeal( + bus=6, + apparent_power_rating=10.0, + capacity=40.0, + initial_soc=20.0, + terminal_soc=20.0, + terminal_constraint=terminal_constraint, + terminal_cost=terminal_cost, + terminal_weight=terminal_weight, + device_id="storage", + ) + ] + stepwise, vectorized = _build_pair(2, storage=storage, delta=delta) + step_results = _solve(stepwise) + vector_results = _solve(vectorized) + _assert_complete_results_equal(step_results, vector_results) + if terminal_cost is not None: + pg = np.asarray(vector_results["Pg"], dtype=float) + power = np.asarray(vector_results["b"], dtype=float) + flows_pu = ( + np.asarray(vector_results["p_flows"], dtype=float) + / vectorized.data["baseMVA"] + ) + generation_cost = delta * _polynomial_generation_cost( + np.asarray(vectorized.data["gencost"], dtype=float), pg + ) + storage_cost = delta * float( + np.sum( + np.asarray(vectorized.data["storage_aging_weight"], dtype=float) + * np.sum(np.abs(power), axis=0) + ) + ) + dc_loss_cost = delta * float( + vectorized.data["loss_weight"] + * np.sum( + np.asarray(vectorized.data["r"], dtype=float) + * np.sum(flows_pu**2, axis=0) + ) + ) + deviation = float(vector_results["soc"][-1, 0] - storage[0].terminal_soc) + terminal_penalty = float(terminal_weight) * deviation**2 + reconstructed_objective = ( + generation_cost + storage_cost + dc_loss_cost + terminal_penalty + ) + assert float(vector_results["objective"]) == pytest.approx( + reconstructed_objective, + abs=1e-5, + ) + + +def test_hvdc_directional_loss_branches_match_stepwise_priority(): + steps = 4 + link = HVDCLink( + from_bus=4, + to_bus=9, + p_min_mw=-10.0, + p_max_mw=10.0, + loss_percent=5.0, + cost_coeffs=(0.0, 0.1, 0.0), + device_id="hvdc", + ) + lower = pd.DataFrame([0.0, -10.0, -5.0, 0.0], columns=["hvdc"]) + upper = pd.DataFrame([10.0, -1.0, 5.0, 0.0], columns=["hvdc"]) + results = [] + for assembly in ("stepwise", "vectorized"): + active, reactive = _legacy_frames(steps) + with warnings.catch_warnings(): + warnings.simplefilter("ignore", UserWarning) + build = build_opf_multistep( + case9(), + active, + reactive, + T=steps, + formulation="lossy_dc", + hvdc=[link], + df_hvdc_min=lower, + df_hvdc_max=upper, + temporal_assembly=assembly, + ) + results.append(_solve(build)) + + _assert_complete_results_equal(results[0], results[1]) + p_in = np.asarray(results[1]["p_hvdc_in"], dtype=float)[:, 0] + p_out = np.asarray(results[1]["p_hvdc_out"], dtype=float)[:, 0] + coefficients = np.array([-1.0 / 0.95, -0.95, -1.0, -1.0 / 0.95]) + np.testing.assert_allclose(p_out, coefficients * p_in, atol=1e-5) + + +def test_piecewise_linear_generator_cost_matches_stepwise(): + case = case9() + generators = gen_from_matpower(case["gen"], case["gencost"]) + first = generators[0] + first.cost_type = "piecewise_linear" + first.cost_coeffs = None + first.cost_points = ( + (first.p_min_mw, 0.0), + ((first.p_min_mw + first.p_max_mw) / 2.0, 500.0), + (first.p_max_mw, 1_200.0), + ) + stepwise, vectorized = _build_pair(2, generators=generators) + _assert_complete_results_equal(_solve(stepwise), _solve(vectorized)) + + +def test_infeasible_and_unsolved_schemas_match_and_keep_fixed_load_inputs(): + case = case9() + case["gen"][:, 8] = 0.0 + case["gen"][:, 9] = 0.0 + active = pd.DataFrame([case["bus"][:, 2]]) + builds = [] + for assembly in ("stepwise", "vectorized"): + builds.append( + build_opf_multistep( + case, + active, + T=1, + formulation="lossy_dc", + temporal_assembly=assembly, + ) + ) + stepwise, vectorized = builds + unsolved = [extract_results(build) for build in builds] + assert unsolved[0].keys() == unsolved[1].keys() + for build in builds: + build.solve() + failed = [extract_results(build) for build in builds] + + assert failed[0].keys() == failed[1].keys() + assert failed[0]["status"] in {"infeasible", "infeasible_inaccurate"} + assert failed[1]["status"] in {"infeasible", "infeasible_inaccurate"} + for result in failed: + assert result["Pg"] is None + assert result["p_flows"] is None + assert result["p_net"] is None + assert np.isnan(result["objective"]) + np.testing.assert_array_equal(result["p_load"], active.to_numpy()) + np.testing.assert_array_equal(result["p_load_served"], active.to_numpy()) + + +def test_solver_exception_retains_stable_production_schema(monkeypatch): + stepwise, vectorized = _build_pair(2) + + def fail_solve(_problem, **_kwargs): + raise cp.error.SolverError("synthetic solver exception") + + monkeypatch.setattr(cp.Problem, "solve", fail_solve) + for build in (stepwise, vectorized): + with pytest.raises(cp.error.SolverError, match="synthetic"): + build.solve() + step_results = extract_results(stepwise) + vector_results = extract_results(vectorized) + + _assert_complete_results_equal(step_results, vector_results) + assert step_results["status"] is None + assert vector_results["status"] is None + assert step_results["Pg"] is None + assert vector_results["Pg"] is None + assert np.isnan(step_results["objective"]) + assert np.isnan(vector_results["objective"]) + + +def test_partial_unusable_primal_retains_stable_production_schema(): + stepwise, vectorized = _build_pair(2) + _solve(stepwise) + _solve(vectorized) + stepwise.variables["Pg"][0].value = None + vectorized.variables["Pg"].value = None + + step_results = extract_results(stepwise) + vector_results = extract_results(vectorized) + + _assert_complete_results_equal(step_results, vector_results) + assert step_results["status"] == cp.OPTIMAL + assert vector_results["status"] == cp.OPTIMAL + assert step_results["Pg"] is None + assert vector_results["Pg"] is None + assert step_results["p_net"] is None + assert vector_results["p_net"] is None + assert np.isfinite(step_results["objective"]) + assert np.isfinite(vector_results["objective"]) + assert step_results["objective"] == pytest.approx( + vector_results["objective"], abs=ATOL + ) + + +@pytest.mark.parametrize("formulation", ["ac", "singlenode_dc"]) +def test_unqualified_vectorized_formulations_are_rejected(formulation: str): + active, reactive = _legacy_frames(1) + context = nullcontext() + with context: + with pytest.raises(NotImplementedError, match="only.*lossy_dc"): + build_opf_multistep( + case9(), + active, + reactive, + T=1, + formulation=formulation, + temporal_assembly="vectorized", + ) + + +def test_vectorized_solve_rejects_conflicting_canonicalization_backend(): + _, vectorized = _build_pair(1) + with pytest.raises(ValueError, match="require SCIPY"): + vectorized.solve(canon_backend=cp.CPP_CANON_BACKEND)