PyAntiGen 1.0.14__tar.gz → 1.0.15__tar.gz

{pyantigen-1.0.14 → pyantigen-1.0.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAntiGen
-Version: 1.0.14
+Version: 1.0.15
 Summary: Short one-line description of what PyAntiGen does
 Author: Open Source Contributor
 Author-email: Don <you@example.com>

{pyantigen-1.0.14 → pyantigen-1.0.15}/PyAntiGen.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAntiGen
-Version: 1.0.14
+Version: 1.0.15
 Summary: Short one-line description of what PyAntiGen does
 Author: Open Source Contributor
 Author-email: Don <you@example.com>

pyantigen-1.0.15/PyAntiGen.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "1.0.15",
+  "distance": 0,
+  "node": "gd95e4a4f4c02ea9c4988d93cc24ff19529147f0c",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-09-30"
+}

{pyantigen-1.0.14 → pyantigen-1.0.15}/framework/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.0.14'
-__version_tuple__ = version_tuple = (1, 0, 14)
+__version__ = version = '1.0.15'
+__version_tuple__ = version_tuple = (1, 0, 15)
 
-__commit_id__ = commit_id = 'gd512f8305'
+__commit_id__ = commit_id = 'gd95e4a4f4'

{pyantigen-1.0.14 → pyantigen-1.0.15}/framework/template/Example/Engine/Evaluator.py

@@ -197,6 +197,10 @@ def _init_worker(spec_blob):
         replicate["Update_parameters"](
             OptRoadRunnerProxy(r, spec.param_names), replicate
         )
+        # Every run in this worker starts from here; see
+        # Optimize.restore_parameter_baseline.
+        from Engine.Optimize import remember_parameter_baseline
+        remember_parameter_baseline(r)
         # The parent's attachment closes over the parent's RoadRunner and could
         # not be shipped here, so it was stripped from the spec. A worker must
         # attach against the model it will integrate anyway -- reusing the
@@ -402,7 +406,9 @@ def _profile_task(job):
             res = None
             outcome = "done"
             if resumable:
-                identity = point_identity(param_idx, x_fixed, x_start.size, method)
+                identity = point_identity(
+                    param_idx, x_fixed, x_start.size, method,
+                    param_name=spec.param_names[param_idx], bounds=bounds)
                 nm_state = state_from_json(
                     load_point_state(state_path, identity), x_start.size)
                 if nm_state is not None:
@@ -642,7 +648,9 @@ class ParallelEvaluator:
             losses = ev.evaluate_batch(xs)
 
     ``evaluate_batch`` preserves input order. Failures come back as
-    ``FAILURE_VALUE`` and are counted in ``ev.n_failures`` rather than raised.
+    ``FAILURE_VALUE`` and are counted in ``ev.n_failures`` rather than raised
+    -- except a broken pool, which raises ``BrokenProcessPool`` so the caller
+    can redo the batch rather than consume a half-sentinel result.
     """
 
     def __init__(self, spec, n_workers=None, chunk_size=None, verbose=True,
@@ -814,6 +822,7 @@ class ParallelEvaluator:
             self.start()
 
         from concurrent.futures import wait, FIRST_COMPLETED
+        from concurrent.futures.process import BrokenProcessPool
 
         t0 = time.time()
         tag = f" [{label}]" if label else ""
@@ -873,6 +882,16 @@ class ParallelEvaluator:
                 i = futures[fut]
                 try:
                     val, status, secs = fut.result()
+                except BrokenProcessPool as exc:
+                    # A dead worker (segfault, OOM kill) fails every future
+                    # still in flight, not just its own. Scoring those as
+                    # sentinels would hand the caller a batch that is part
+                    # real values and part 1e10 -- a Hessian stencil built
+                    # from that is finite and silently meaningless. Raise so
+                    # the caller redoes the whole batch serially instead.
+                    raise BrokenProcessPool(
+                        f"worker pool broke during batch{tag} after "
+                        f"{done}/{n} evaluation(s): {exc}") from exc
                 except Exception as exc:
                     val = FAILURE_VALUE
                     status = f"error: {type(exc).__name__}: {exc}"

{pyantigen-1.0.14 → pyantigen-1.0.15}/framework/template/Example/Engine/Optimize.py

@@ -301,6 +301,59 @@ def _resolve_obs_df(df_dict, obs_cfg):
     )
 
 
+# ---------------------------------------------------------------------------
+# Global parameters an event assigned survive r.reset()
+# ---------------------------------------------------------------------------
+#
+# RoadRunner's reset() restores time, floating species and rate-rule values,
+# but NOT a global parameter that an event assigned during the previous run.
+# An arm whose events switch something on and leave it on -- a labelling
+# fraction, a washout rate, a catheter drain -- therefore starts every
+# simulation after the first from birth with that switch already thrown, and
+# the objective stops being a function of the parameters alone: the first
+# evaluation differs from every later one at the same point.
+#
+# Measured on the Cook arms, whose end-of-infusion event leaves k_leu_washout
+# at 0.125: at cook_turnover's 2026-09-29 optimum the first evaluation drew a
+# vehicle NewAB40_CM peak of 1523 pM at 18.5 h and every later one 690 pM at
+# 13.3 h, the label washing out from t = 0. The fit minimized the second
+# function while --simulate (a fresh model, one run) draws the first.
+#
+# Ported from PyAntiGen v2 (cdf1fd8). Each model's global parameter values are
+# recorded once, when the Engine builds it, and run_all puts back any that
+# differ after every reset(). Only parameters the run changed are touched, and
+# assignment-rule parameters, which cannot be set, are skipped. A model built
+# elsewhere is recorded the first time run_all sees it.
+
+def remember_parameter_baseline(r):
+    """Record r's settable global parameter values as its per-run start."""
+    ids = list(r.getGlobalParameterIds())
+    rules = set(r.getAssignmentRuleIds())
+    idx = np.array([i for i, p in enumerate(ids) if p not in rules], dtype=int)
+    vals = np.asarray(r.getGlobalParameterValues(), dtype=float)
+    r._pyantigen_param_baseline = (ids, idx, vals[idx].copy())
+
+
+def restore_parameter_baseline(r):
+    """Put back every settable global parameter that differs from the baseline.
+
+    Returns the names restored (empty when nothing had changed).
+    """
+    base = getattr(r, "_pyantigen_param_baseline", None)
+    if base is None:
+        remember_parameter_baseline(r)
+        return []
+    ids, idx, vals = base
+    cur = np.asarray(r.getGlobalParameterValues(), dtype=float)[idx]
+    changed = np.flatnonzero(~((cur == vals) | (np.isnan(cur) & np.isnan(vals))))
+    names = []
+    for j in changed:
+        name = ids[idx[j]]
+        r[name] = float(vals[j])
+        names.append(name)
+    return names
+
+
 def run_all(r, exp_num, experiment, df_dict, set_parameters=None, parameters=None,
             preequil_cache=None):
     """
@@ -318,6 +371,9 @@ def run_all(r, exp_num, experiment, df_dict, set_parameters=None, parameters=Non
     Returns a results dict keyed by treatment label.
     """
     r.reset()
+    # reset() leaves event-assigned global parameters at their end-of-run
+    # values; see restore_parameter_baseline.
+    restore_parameter_baseline(r)
 
     # Re-apply treatment-specific parameters which were wiped out by r.reset()
     update_params = experiment.get("Update_parameters")
@@ -1674,7 +1730,9 @@ def compute_hessian_numdifftools(func, params):
 # _finite_difference_steps: 0.02 keeps the noise term 4*sigma/h^2 near 0.1 for
 # objective noise anywhere from 1e-7 to 1e-4 nats, while the truncation term
 # H*h^2/12 stays near 0.003 for curvatures of order 100. Two decades of margin
-# either side, which is what a numerically noisy objective needs.
+# either side, which is what a numerically noisy objective needs. It is the
+# starting and largest step: compute_hessian_batched shrinks it per parameter
+# where the curvature is too high for it (see _FD_TARGET_RISE).
 _LOG_FD_STEP = 0.02
 
 
@@ -1706,6 +1764,10 @@ def _finite_difference_steps(params, epsilon=1e-4, abs_floor=None, scales=None,
     1e-5 nats, not 1e-16. At h=3e-4 that is an error near 450 against curvatures
     of order 100: the Hessian becomes noise, the matrix stops being positive
     definite, and sqrt(diag(inv(H))) returns NaN.
+
+    For log10 coordinates this is only the starting step. A parameter whose
+    SE is comparable to it is probed outside its quadratic region, and
+    compute_hessian_batched shrinks the step for it (_calibrate_log_steps).
     """
     params = np.atleast_1d(np.asarray(params, dtype=float))
     if abs_floor is None:
@@ -1727,7 +1789,101 @@ def _finite_difference_steps(params, epsilon=1e-4, abs_floor=None, scales=None,
     return steps
 
 
-def compute_hessian_batched(nll_batch, params, epsilon=1e-4, scales=None):
+# A log10 step is sized so that one diagonal probe raises the NLL by about this
+# many nats. _LOG_FD_STEP alone is a single compromise for every parameter, and
+# it fails in the tight direction: on the Example spec two parameters with SEs
+# near 0.01 decades sat 2 SEs from the centre at a 0.02-decade step, outside
+# the quadratic region, and came back with SEs 12% and 18% off and a
+# correlation of -0.25 instead of -0.55. Sizing by the rise instead balances
+# both errors for every parameter at once: truncation is set by how far past
+# quadratic the probe reaches, which a rise of a tenth of a nat keeps small,
+# and the noise term 4*sigma/h^2 relative to the curvature is about
+# 2*sigma/rise, ~2e-4 at sigma = 1e-5 nats. At 0.1 the Example's log10 SEs
+# land within 0.3% of the exact values; at 0.2, within 0.5%.
+_FD_TARGET_RISE = 0.1
+# Smallest log10 step the calibration may choose, in decades. Below this the
+# noise term takes over again on an ODE objective.
+_LOG_FD_STEP_MIN = 1e-4
+
+
+def _check_stencil_values(vals, failure_value, what):
+    """Raise if any stencil value is non-finite or the failure sentinel."""
+    # The failure sentinel is finite, so a stencil point that failed to
+    # integrate would otherwise pass straight through as a curvature of order
+    # 1e10/h^2 and come out the other side as a plausible-looking SE.
+    bad = ~np.isfinite(vals) | (vals >= failure_value)
+    if np.any(bad):
+        raise ValueError(
+            f"{int(bad.sum())}/{vals.size} {what} point(s) failed to evaluate "
+            f"(failure sentinel or non-finite NLL); the Hessian would be "
+            f"meaningless.")
+
+
+def _calibrate_log_steps(nll_batch, params, steps, scales, failure_value,
+                         target=_FD_TARGET_RISE, min_step=_LOG_FD_STEP_MIN,
+                         max_passes=4):
+    """Shrink each log10 step until one probe raises the NLL by ~*target* nats.
+
+    A pilot pass evaluates the centre and +/- the default step for every
+    log10 parameter. Its mean rise r approximates H_ii h^2 / 2, so the step
+    that gives a rise of *target* is h * sqrt(target / r). A step is accepted
+    once its rise is at most twice *target*.
+
+    That estimate is taken from a probe that is, by construction, too far out,
+    and on a likelihood shaped like (n/2) log(SSE) -- which flattens away from
+    the optimum -- it underestimates the curvature, so a single rescaling can
+    still land a probe at a rise of a nat or more. Parameters whose new step
+    still rises too far are therefore probed again, up to *max_passes* passes
+    in all; each extra pass costs 2 evaluations per such parameter only.
+
+    Steps only shrink: a parameter whose default probe rises less than the
+    limit is inside its quadratic region, and there the larger step is the
+    better defence against integration noise. A rise that is not positive -- a
+    flat or noisy direction -- also keeps the default, as does a step that has
+    reached *min_step*.
+
+    Returns ``(steps, known)``: the calibrated steps, and the pilot values
+    ``{point_key: value}`` evaluated at them, so the stencil does not evaluate
+    the same point twice.
+    """
+    pending = [i for i, s in enumerate(scales or [])
+               if s == "log10" and i < params.size]
+    if not pending:
+        return steps, {}
+
+    steps = np.array(steps, dtype=float, copy=True)
+    known = {}
+    for _ in range(max_passes):
+        points = [] if known else [params.copy()]
+        for i in pending:
+            p_plus = params.copy(); p_plus[i] += steps[i]
+            p_minus = params.copy(); p_minus[i] -= steps[i]
+            points += [p_plus, p_minus]
+        vals = np.asarray(nll_batch(points, label="hessian-step"), dtype=float)
+        _check_stencil_values(vals, failure_value, "Hessian step-calibration")
+        if not known:
+            known[("c",)] = float(vals[0])
+            vals = vals[1:]
+        f0 = known[("c",)]
+
+        still = []
+        for k, i in enumerate(pending):
+            f_plus, f_minus = float(vals[2 * k]), float(vals[2 * k + 1])
+            rise = 0.5 * (f_plus + f_minus) - f0
+            if rise > 2.0 * target and steps[i] > min_step:
+                steps[i] = max(min_step, steps[i] * np.sqrt(target / rise))
+                still.append(i)
+            else:
+                known[("d", i, +1)] = f_plus
+                known[("d", i, -1)] = f_minus
+        pending = still
+        if not pending:
+            break
+    return steps, known
+
+
+def compute_hessian_batched(nll_batch, params, epsilon=1e-4, scales=None,
+                            failure_value=1e10):
     """Central-difference Hessian evaluated as one batch.
 
     The stencil is fixed in advance -- 1 centre, 2k diagonal points and 4 points
@@ -1735,41 +1891,49 @@ def compute_hessian_batched(nll_batch, params, epsilon=1e-4, scales=None):
     instead of trickling through numdifftools one call at a time. That is
     2k^2 + 1 evaluations with no dependencies, which is exactly what the pool
     is for.
+
+    Log10 steps are calibrated first (see :func:`_calibrate_log_steps`). Its
+    pilot values are reused for the final steps, so a parameter whose default
+    step already fits costs nothing extra, and one that had to shrink costs 2
+    evaluations per calibration pass.
     """
     params = np.atleast_1d(np.asarray(params, dtype=float))
     n = params.size
     steps = _finite_difference_steps(params, epsilon, scales=scales)
+    steps, known = _calibrate_log_steps(nll_batch, params, steps, scales,
+                                        failure_value)
 
-    points = [params.copy()]           # index 0: centre
-    index = {}
-
+    # Every stencil point by key; the ones the calibration already evaluated
+    # are filled in from it, the rest go to the pool in one batch.
+    keys, points = [("c",)], [params.copy()]
     for i in range(n):
-        p_plus = params.copy(); p_plus[i] += steps[i]
-        p_minus = params.copy(); p_minus[i] -= steps[i]
-        index[("d", i)] = (len(points), len(points) + 1)
-        points += [p_plus, p_minus]
-
+        for sign in (+1, -1):
+            p = params.copy(); p[i] += sign * steps[i]
+            keys.append(("d", i, sign)); points.append(p)
     for i in range(n):
         for j in range(i + 1, n):
-            pp = params.copy(); pp[i] += steps[i]; pp[j] += steps[j]
-            pm = params.copy(); pm[i] += steps[i]; pm[j] -= steps[j]
-            mp = params.copy(); mp[i] -= steps[i]; mp[j] += steps[j]
-            mm = params.copy(); mm[i] -= steps[i]; mm[j] -= steps[j]
-            index[("o", i, j)] = tuple(range(len(points), len(points) + 4))
-            points += [pp, pm, mp, mm]
-
-    vals = np.asarray(nll_batch(points, label="hessian"), dtype=float)
-    f0 = vals[0]
+            for si, sj in ((+1, +1), (+1, -1), (-1, +1), (-1, -1)):
+                p = params.copy(); p[i] += si * steps[i]; p[j] += sj * steps[j]
+                keys.append(("o", i, j, si, sj)); points.append(p)
+
+    todo = [k for k, key in enumerate(keys) if key not in known]
+    fresh = np.asarray(nll_batch([points[k] for k in todo], label="hessian"),
+                       dtype=float)
+    _check_stencil_values(fresh, failure_value, "Hessian stencil")
+    val = dict(known)
+    val.update({keys[k]: float(v) for k, v in zip(todo, fresh)})
+    f0 = val[("c",)]
 
     hessian = np.zeros((n, n))
     for i in range(n):
-        a, b = index[("d", i)]
-        hessian[i, i] = (vals[a] - 2.0 * f0 + vals[b]) / (steps[i] ** 2)
+        hessian[i, i] = (val[("d", i, +1)] - 2.0 * f0
+                         + val[("d", i, -1)]) / (steps[i] ** 2)
     for i in range(n):
         for j in range(i + 1, n):
-            a, b, c, d = index[("o", i, j)]
-            val = (vals[a] - vals[b] - vals[c] + vals[d]) / (4.0 * steps[i] * steps[j])
-            hessian[i, j] = hessian[j, i] = val
+            h_ij = (val[("o", i, j, +1, +1)] - val[("o", i, j, +1, -1)]
+                    - val[("o", i, j, -1, +1)] + val[("o", i, j, -1, -1)]
+                    ) / (4.0 * steps[i] * steps[j])
+            hessian[i, j] = hessian[j, i] = h_ij
     return hessian
 
 
@@ -1875,11 +2039,20 @@ def compute_wald_uncertainty(nll_func, x, bounds=None, loss_scale=1.0, alpha=0.0
     print(f"\n[Wald] Computing Hessian for {k} parameter(s) "
           f"(~{n_evals} silent NLL evaluations)...")
 
+    if nll_batch is None:
+        # Serial runs (no worker pool) go through the same stencil as pooled
+        # ones, evaluated one point at a time. The numdifftools route used to
+        # be taken here, with a fixed absolute step of 1e-5 and no knowledge of
+        # parameter scales: far below the ODE objective's numerical noise for a
+        # log10 coordinate, and larger than the parameter itself for a small
+        # linear rate constant -- the two failures _finite_difference_steps
+        # exists to prevent. It also bypassed the failure-sentinel check, and
+        # made a serial run's SEs incomparable with a pooled run's.
+        def nll_batch(xs, label=None):
+            return [nll_func(np.asarray(xi, dtype=float)) for xi in xs]
+
     try:
-        if nll_batch is not None:
-            hessian_raw = compute_hessian_batched(nll_batch, x, scales=scales)
-        else:
-            hessian_raw = compute_hessian_numdifftools(nll_func, x)
+        hessian_raw = compute_hessian_batched(nll_batch, x, scales=scales)
     except Exception as exc:
         print(f"[Wald] Hessian computation failed: {exc}")
         return None, None, nan_ci
@@ -5575,6 +5748,7 @@ def run_optimization(
         r          = TelluriumGen(model_text + "\n" + events_str, paths)
         r_proxy    = OptRoadRunnerProxy(r, param_names)
         experiment["Update_parameters"](r_proxy, experiment)
+        remember_parameter_baseline(r)
         attach_event_times(experiment, r, verbose=True)
 
         models[exp_num] = {"r_ic": r_ic, "r": r, "df_dict": df_dict}
@@ -6015,6 +6189,8 @@ def run_optimization_from_groups(
             r = TelluriumGen(model_text + "\n" + events_str, paths)
             r_proxy = OptRoadRunnerProxy(r, param_names)
             replicate["Update_parameters"](r_proxy, replicate)
+            # Before anything integrates it: every later run starts from here.
+            remember_parameter_baseline(r)
 
             # Where this arm's discontinuities are, read off the compiled model.
             # Attached rather than computed, because a trigger built on a fitted

{pyantigen-1.0.14 → pyantigen-1.0.15}/framework/template/Example/Engine/Profile_checkpoint.py

@@ -116,7 +116,7 @@ def point_state_path(state_dir, param_name, x_fixed):
     return os.path.join(state_dir, _safe_name(f"{param_name}__{key!r}") + ".json")
 
 
-def point_identity(param_idx, x_fixed, n_nuisance, method):
+def point_identity(param_idx, x_fixed, n_nuisance, method, param_name, bounds):
     """What a saved state must match to be resumed by a job.
 
     Deliberately not the job's starting point or its simplex: those differ
@@ -124,10 +124,42 @@ def point_identity(param_idx, x_fixed, n_nuisance, method):
     stopped on the clock is resumed from a record, not from the job that began
     it), and a state is the more exact of the two resume sources whenever it
     exists. What it must never be is another *problem*.
+
+    THAT GUARANTEE WAS MISSING until 2026-09-25. ``param_idx`` is a POSITION,
+    not an identity: a reparametrization that keeps the same total and
+    nuisance parameter counts but changes what occupies each slot leaves
+    ``param_idx``, ``n`` and ``method`` all unchanged while the meaning of
+    every nuisance coordinate changes underneath them. This happened for
+    real the same day -- four independent k_gammasec_*_base constants
+    (silk_appfull, slots 5-8) were replaced by Vm_C99_Abeta_base and the
+    softmax logits y_gammaAB38/40/42, same 18 total, same 17 nuisance, same
+    slots -- and a state resumed from before the change into a run after it
+    would have been accepted, with the incumbent vertex it carried never
+    revalidated against the new bounds (``Engine.Nelder_mead.state_from_json``
+    checks shape, not bounds; only a *fresh* ``new_state`` clips). ``bounds``
+    closes the same gap for a bounds-only change: :func:`spec_fingerprint`
+    does not hash bounds at all, so tightening or correcting one does not
+    start a new checkpoint directory on its own, and nothing else stood
+    between an old, wider-bounded simplex and a run enforcing a new bound.
+
+    ``param_name`` and ``bounds`` are therefore folded into the identity
+    below as a hash, not compared field by field: their exact representation
+    (a numpy dtype, a tuple vs a list) can differ harmlessly between the run
+    that wrote a state and the one resuming it, and a hash of their JSON form
+    is stable across that while still changing the moment either actually
+    means something different.
     """
-    return {"param_idx": int(param_idx),
-            "x_fixed": round(float(x_fixed), 12),
-            "n": int(n_nuisance), "method": str(method).lower()}
+    payload = {"param_idx": int(param_idx),
+               "x_fixed": round(float(x_fixed), 12),
+               "n": int(n_nuisance), "method": str(method).lower()}
+    blob = json.dumps({
+        "param_name": str(param_name),
+        "bounds": [None if b is None else
+                   [None if v is None else round(float(v), 12) for v in b]
+                   for b in bounds] if bounds is not None else None,
+    }, sort_keys=True)
+    payload["fingerprint"] = hashlib.sha256(blob.encode("utf-8")).hexdigest()[:16]
+    return payload
 
 
 def save_point_state(path, identity, nm_state):
@@ -338,11 +370,18 @@ def spec_fingerprint(param_names, x_opt, groups, scales, model_text,
             #      sigma profiled out analytically. It is the same function the
             #      fit minimizes, so its dNLL is on a different scale again and
             #      v1/v2 points must not be resumed into a v3 run.
-            "likelihood_convention": "v3-concentrated-gaussian",
-            # Under v3 sigma is profiled out per evaluation rather than frozen,
-            # so these no longer enter dNLL. They are still hashed because they
-            # are a compact fingerprint of the residuals at the optimum, which
-            # does change whenever the fit lands somewhere else.
+            #   v4 keeps v3 for the fit, Wald and slices, but evaluates every
+            #      profile point with each sigma-floored block pinned at its
+            #      own sigma_used from the fit (Optimize._freeze_floor), and
+            #      measures dNLL from an anchor computed the same way. v3
+            #      points re-concentrated those sigmas at every point, so they
+            #      sit on a different curve and must not be resumed into v4.
+            "likelihood_convention": "v4-concentrated-gaussian-frozen-floor",
+            # The fit's per-block sigmas. Unfloored blocks are still profiled
+            # out per evaluation, but floored blocks are frozen at these values
+            # for every profile point, so they now enter dNLL directly -- a
+            # different sigma is a different profile. Also a compact
+            # fingerprint of the residuals at the optimum.
             "sigmas": sorted(
                 (str(k), round(float(v), 12))
                 for k, v in (fixed_sigmas or {}).items()

pyantigen-1.0.14/PyAntiGen.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "1.0.14",
-  "distance": 0,
-  "node": "gd512f83056b8ddfb329244c8f23a6b90a2408735",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-09-23"
-}