"""Generated by ReactiveKernelsPPL.jax_source from a built @rkppl program; do not edit.

Data: g, g_fit, x, y.

Model documentation:

- `mu`: Expected response: a population line, and each group's own intercept and slope, correlated.
- `sigma`: Residual scale of the response.
- `y`: Measured response.
- `b_mu__g_g`: Group-level (varying) effects of grouping `g`, `K` correlated margins per level.

  Non-centered, from the scales `tau[1:K]` (drawn from their priors), the Cholesky factor of the margins' correlation `L ~ LKJCholesky(K, eta)` and standardized effects
  `z[1:length(levels(g)), 1:K] ~ Normal(0, 1)`. Returns the
  level-by-margin matrix `z * transpose(tau .* L)`, one row per level of `g` in order.
- `pop_mu`: Population-level effects: one coefficient per column of the design matrix `X`.

  Draws `beta_pop[1:ncoef] ~ Normal(loc, scale)` and returns the linear predictor
  `X * beta_pop`. `ncoef` is the number of columns of `X`. Each prior argument (`loc`, `scale`) is one value for all coefficients or a vector with one per coefficient.
"""
import numpy as np
import scipy.special as ssp
from typing import Any

import jax
import jax.numpy as jnp
import jax.scipy.linalg
import jax.scipy.special as jsp
from jax.typing import ArrayLike

jax.config.update("jax_enable_x64", True)

DATA = {"g": {"dtype": "object", "ndim": 1, "ragged": False}, "g_fit": {"dtype": "object", "ndim": 1, "ragged": False}, "x": {"dtype": "float64", "ndim": 1, "ragged": False}, "y": {"dtype": "float64", "ndim": 1, "ragged": False}}
INPUTS = ("unconstrained", "ppl_last_b_mu_g_g_z", "ppl_axis1_b_mu_g_g_z", "ppl_first_pop_mu_beta_pop", "ppl_last_pop_mu_beta_pop", "g_level", "x", "X_mu", "y")
PREPARED = {"ppl_last_b_mu_g_g_z": {"dtype": "int64", "ndim": 0, "ragged": False}, "ppl_axis1_b_mu_g_g_z": {"dtype": "int64", "ndim": 0, "ragged": False}, "ppl_first_pop_mu_beta_pop": {"dtype": "int64", "ndim": 0, "ragged": False}, "ppl_last_pop_mu_beta_pop": {"dtype": "int64", "ndim": 0, "ragged": False}, "g_level": {"dtype": "int64", "ndim": 1, "ragged": False}, "x": {"dtype": "float64", "ndim": 1, "ragged": False}, "X_mu": {"dtype": "float64", "ndim": 2, "ragged": False}, "y": {"dtype": "float64", "ndim": 1, "ragged": False}}
UNTRANSLATED = {}


def _rk_order_key_np(x):
    # Julia's isless order of an array as sortable keys: a float is an integer
    # key, -0.0 before 0.0 and every NaN last, equal for values isequal treats
    # as equal. Integer and string arrays are their own keys.
    x = np.asarray(x)
    if x.dtype.kind != "f":
        return x
    bits = np.where(np.isnan(x), np.nan, x).astype(np.float64).view(np.int64)
    return np.where(bits < 0, bits ^ np.int64(0x7FFFFFFFFFFFFFFF), bits)


def _rk_unique_np(x):
    # Julia's unique of a vector: the first value of each isequal class, in
    # order.
    x = np.asarray(x)
    _, first = np.unique(_rk_order_key_np(x), return_index=True)
    return x[np.sort(first)]


def _rk_sort_np(x):
    # Julia's sort of a vector: ascending in isless order, equal values in
    # their order.
    x = np.asarray(x)
    return x[np.argsort(_rk_order_key_np(x), kind="stable")]


def _brm_sorted_labels_np(source):
    labels = _rk_unique_np(source)
    sorted_ = _rk_sort_np(labels)
    return sorted_


def _brm_fit_levels_np(source):
    value = _brm_sorted_labels_np(source)
    levels = value
    return levels


def _rk_dict_key(x):
    if isinstance(x, tuple):
        return (1, tuple(map(_rk_dict_key, x)))
    if isinstance(x, np.ndarray):
        return (2, x.shape, tuple(map(_rk_dict_key, x.ravel(order="F"))))
    if isinstance(x, (complex, np.complexfloating)):
        if x.imag == 0 and not np.signbit(x.imag):
            return _rk_dict_key(x.real)
        return (3, _rk_dict_key(x.real), _rk_dict_key(x.imag))
    if isinstance(x, (float, np.floating)):
        if np.isnan(x):
            return (4,)
        if x == 0 and np.signbit(x):
            return (5,)
    return (0, x)

class _RKDict:
    def __init__(self, pairs=()):
        self.data = {}
        for key, value in pairs:
            self[key] = value

    def __len__(self):
        return len(self.data)

    def __contains__(self, key):
        return _rk_dict_key(key) in self.data

    def __getitem__(self, key):
        return self.data[_rk_dict_key(key)][1]

    def __setitem__(self, key, value):
        self.data[_rk_dict_key(key)] = (key, value)

    def get(self, key, default):
        item = self.data.get(_rk_dict_key(key))
        return default if item is None else item[1]

    def setdefault(self, key, default):
        return self.data.setdefault(_rk_dict_key(key), (key, default))[1]

    def pop(self, key, default):
        item = self.data.pop(_rk_dict_key(key), None)
        return default if item is None else item[1]

    def items(self):
        return self.data.values()

    def keys(self):
        return (item[0] for item in self.items())

    def values(self):
        return (item[1] for item in self.items())

    def copy(self):
        return _RKDict(self.items())


def _brm_level_indices_np(labels, source):
    value = _brm_fit_levels_np(source)
    levels = value
    lookup = _RKDict()
    for k in range(1, len(levels) + 1):
        lookup[levels[k - 1]] = k
    indices = np.zeros((len(labels),), dtype=np.int64)
    for r in range(1, len(labels) + 1):
        position = lookup.get(labels[r - 1], 0)
        if position == 0:
            raise ValueError("".join([str("RK backend: group label `"), str(labels[r - 1]), str("` is not one of the "), str(len(levels)), str(" fitted levels. A replay keeps the fitted levels of every grouping it does not resample; name the grouping in `resample_groups` to take the new data's own levels.")]))
        indices[r - 1] = position
    return indices


def _rk_levels_np(x):
    arr = np.asarray(x)
    values = sorted(set(v for v in arr.tolist() if v is not None))
    return np.array(values, dtype=object if arr.dtype == object else arr.dtype)


class StaticInt(int):
    """An integer of the prepared data that sets a shape.

    It is an `int` everywhere, and `jax.jit` treats it as static, so the
    functions jit with the prepared data as arguments; a new value traces
    them again.
    """

    def __repr__(self):
        return "StaticInt(%d)" % int(self)


jax.tree_util.register_pytree_node(StaticInt, lambda s: ((), int(s)), lambda v, _: StaticInt(v))


def brm_population_effects(X: ArrayLike, beta_pop: ArrayLike, *, outputs: tuple[str, ...]) -> dict:
    """Population-level effects: one coefficient per column of the design matrix `X`.

    Draws `beta_pop[1:ncoef] ~ Normal(loc, scale)` and returns the linear predictor
    `X * beta_pop`. `ncoef` is the number of columns of `X`. Each prior argument (`loc`, `scale`) is one value for all coefficients or a vector with one per coefficient.
    """
    results = {}
    if any(name in outputs for name in ("value",)):
        value = X @ beta_pop
    if any(name in outputs for name in ("ppl_prior_beta_pop", "ppl_pw_prior_beta_pop")):
        ppl_parg_beta_pop_2 = jnp.asarray([2.0, 1.0], dtype=jnp.float64)
        def ppl_pw_prior_beta_pop_cell(beta_pop_2, scale):
            log_scale = jnp.log(scale)
            standardized = (beta_pop_2 - 0.0) / jnp.where(jnp.logical_and(scale == 0, beta_pop_2 == 0.0), 1.0, scale)
            standard_logpdf = -0.5 * np.log(2 * np.pi) - 0.5 * standardized ** 2
            logpdf = standard_logpdf - jnp.where(jnp.logical_and(scale == 0, beta_pop_2 != 0.0), 0.0, log_scale)
            return logpdf
        ppl_pw_prior_beta_pop = (jnp.zeros(beta_pop.shape[:1], dtype=jnp.float64) if 0 in beta_pop.shape[:1] and ppl_parg_beta_pop_2.shape[:1] == beta_pop.shape[:1] else jax.vmap(ppl_pw_prior_beta_pop_cell, in_axes=(0, 0))(beta_pop, ppl_parg_beta_pop_2))
    if any(name in outputs for name in ("ppl_prior_beta_pop",)):
        ppl_prior_beta_pop = jnp.sum(ppl_pw_prior_beta_pop)
    if "ppl_prior_beta_pop" in outputs:
        results["ppl_prior_beta_pop"] = ppl_prior_beta_pop
    if "ppl_pw_prior_beta_pop" in outputs:
        results["ppl_pw_prior_beta_pop"] = ppl_pw_prior_beta_pop
    if "value" in outputs:
        results["value"] = value
    return results


def brm_correlated_group_effects_density(
    ppl_last_z: ArrayLike,
    tau: ArrayLike,
    unconstrained: ArrayLike,
    *,
    outputs: tuple[str, ...],
) -> dict:
    """Group-level (varying) effects of grouping `g`, `K` correlated margins per level.

    Non-centered, from the scales `tau[1:K]` (drawn from their priors), the Cholesky factor of the margins' correlation `L ~ LKJCholesky(K, eta)` and standardized effects
    `z[1:length(levels(g)), 1:K] ~ Normal(0, 1)`. Returns the
    level-by-margin matrix `z * transpose(tau .* L)`, one row per level of `g` in order.
    """
    results = {}
    if any(name in outputs for name in ("ppl_lkj_diagonal_L", "ppl_lkj_partials_L", "ppl_lkj_raw_L", "ppl_prior_L")):
        ppl_lkj_raw_L = unconstrained[3:4]
    if any(name in outputs for name in ("ppl_lkj_diagonal_L", "ppl_lkj_partials_L", "ppl_prior_L")):
        ppl_lkj_partials_L = jnp.tanh(ppl_lkj_raw_L)
    if any(name in outputs for name in ("ppl_lkj_diagonal_L", "ppl_prior_L")):
        out = jnp.ones((2,), dtype=jnp.float64)
        tuple_ = (1, 2, 1.0)
        i = tuple_[0]
        j = tuple_[1]
        d = tuple_[2]
        def loop_body(p, carry):
            (d_2, i_2, j_2, out_2) = carry
            d_3 = d_2 * jnp.sqrt(1 - ppl_lkj_partials_L[p - 1] ** 2)
            def then_arm():
                i_3 = i_2 + 1
                return (None, jnp.asarray(d_3, dtype=jnp.float64), jnp.asarray(i_3, dtype=jnp.int64), jnp.asarray(j_2, dtype=jnp.int64), out_2)
            def else_arm():
                out_3 = out_2.at[j_2 - 1].set(d_3)
                tuple__2 = (1, j_2 + 1, 1.0)
                i_4 = tuple__2[0]
                j_3 = tuple__2[1]
                d_4 = tuple__2[2]
                return (None, jnp.asarray(d_4, dtype=jnp.float64), jnp.asarray(i_4, dtype=jnp.int64), jnp.asarray(j_3, dtype=jnp.int64), out_3)
            branch = jax.lax.cond(i_2 + 1 < j_2, then_arm, else_arm)
            return (branch[1], branch[2], branch[3], branch[4])
        loop_carry = jax.lax.fori_loop(1, 2, loop_body, (jnp.asarray(d, dtype=jnp.float64), jnp.asarray(i, dtype=jnp.int64), jnp.asarray(j, dtype=jnp.int64), out))
        ppl_lkj_diagonal_L = loop_carry[3]
    if any(name in outputs for name in ("ppl_arrflat_z", "ppl_prior_z", "ppl_pw_prior_z")):
        ppl_arrflat_z = unconstrained[4:ppl_last_z]
    if any(name in outputs for name in ("ppl_prior_tau", "ppl_pw_prior_tau")):
        def ppl_pw_prior_tau_cell(tau_2):
            log_scale = np.log(1.0)
            logpdf = jax.lax.cond(tau_2 < 0, lambda: -jnp.inf, lambda: -log_scale - tau_2 / 1.0)
            return logpdf
        ppl_pw_prior_tau = (jnp.zeros(tau.shape[:1], dtype=jnp.float64) if 0 in tau.shape[:1] else jax.vmap(ppl_pw_prior_tau_cell, in_axes=(0,))(tau))
    if any(name in outputs for name in ("ppl_prior_tau",)):
        ppl_prior_tau = jnp.sum(ppl_pw_prior_tau)
    if any(name in outputs for name in ("ppl_prior_L",)):
        total = -0.6931471805599453
        def loop_body_2(i_2, carry_2):
            (total_2,) = carry_2
            total_3 = total_2 + (2 - i_2) * jnp.log(ppl_lkj_diagonal_L[i_2 - 1])
            return (total_3,)
        loop_carry_2 = jax.lax.fori_loop(2, 3, loop_body_2, (jnp.asarray(total, dtype=jnp.float64),))
        ppl_prior_L = loop_carry_2[0]
    if any(name in outputs for name in ("ppl_prior_z", "ppl_pw_prior_z")):
        def ppl_pw_prior_z_cell(z):
            log_scale = np.log(1.0)
            standardized = (z - 0.0) / jnp.where((z == 0.0 if 1.0 == 0 else False), 1.0, 1.0)
            standard_logpdf = -0.5 * np.log(2 * np.pi) - 0.5 * standardized ** 2
            logpdf = standard_logpdf - jnp.where((z != 0.0 if 1.0 == 0 else False), 0.0, log_scale)
            return logpdf
        ppl_pw_prior_z = (jnp.zeros(ppl_arrflat_z.shape[:1], dtype=jnp.float64) if 0 in ppl_arrflat_z.shape[:1] else jax.vmap(ppl_pw_prior_z_cell, in_axes=(0,))(ppl_arrflat_z))
    if any(name in outputs for name in ("ppl_prior_z",)):
        ppl_prior_z = jnp.sum(ppl_pw_prior_z)
    if "ppl_arrflat_z" in outputs:
        results["ppl_arrflat_z"] = ppl_arrflat_z
    if "ppl_lkj_diagonal_L" in outputs:
        results["ppl_lkj_diagonal_L"] = ppl_lkj_diagonal_L
    if "ppl_lkj_partials_L" in outputs:
        results["ppl_lkj_partials_L"] = ppl_lkj_partials_L
    if "ppl_lkj_raw_L" in outputs:
        results["ppl_lkj_raw_L"] = ppl_lkj_raw_L
    if "ppl_prior_L" in outputs:
        results["ppl_prior_L"] = ppl_prior_L
    if "ppl_prior_tau" in outputs:
        results["ppl_prior_tau"] = ppl_prior_tau
    if "ppl_prior_z" in outputs:
        results["ppl_prior_z"] = ppl_prior_z
    if "ppl_pw_prior_tau" in outputs:
        results["ppl_pw_prior_tau"] = ppl_pw_prior_tau
    if "ppl_pw_prior_z" in outputs:
        results["ppl_pw_prior_z"] = ppl_pw_prior_z
    return results


def _ppl_lkj_lower(z: ArrayLike, diagonal: ArrayLike, K: ArrayLike, P: ArrayLike) -> jax.Array:
    """Compute `_ppl_lkj_lower` from its authored source."""
    out = jnp.zeros((K, K), dtype=jnp.float64)
    out_2 = out.at[0, 0].set(1.0)
    tuple_ = (1, 2, 1.0)
    i = tuple_[0]
    j = tuple_[1]
    w = tuple_[2]
    def loop_body(p, carry):
        (i_2, j_2, out_3, w_2) = carry
        out_4 = out_3.at[j_2 - 1, i_2 - 1].set(z[p - 1] * w_2)
        w_3 = w_2 * jnp.sqrt(1 - z[p - 1] ** 2)
        def then_arm():
            i_3 = i_2 + 1
            return (None, jnp.asarray(i_3, dtype=jnp.int64), jnp.asarray(j_2, dtype=jnp.int64), out_4, jnp.asarray(w_3, dtype=jnp.float64))
        def else_arm():
            out_5 = out_4.at[j_2 - 1, j_2 - 1].set(diagonal[j_2 - 1])
            tuple__2 = (1, j_2 + 1, 1.0)
            i_4 = tuple__2[0]
            j_3 = tuple__2[1]
            w_4 = tuple__2[2]
            return (None, jnp.asarray(i_4, dtype=jnp.int64), jnp.asarray(j_3, dtype=jnp.int64), out_5, jnp.asarray(w_4, dtype=jnp.float64))
        branch = jax.lax.cond(i_2 + 1 < j_2, then_arm, else_arm)
        return (branch[1], branch[2], branch[3], branch[4])
    carry_init = (jnp.asarray(i, dtype=jnp.int64), jnp.asarray(j, dtype=jnp.int64), out_2, jnp.asarray(w, dtype=jnp.float64))
    loop_carry = jax.lax.fori_loop(1, P + 1, loop_body, carry_init) if 1 <= P else carry_init
    return loop_carry[2]


def brm_correlated_group_effects(
    L: ArrayLike,
    tau: ArrayLike,
    z: ArrayLike,
    *,
    outputs: tuple[str, ...],
) -> dict:
    """Group-level (varying) effects of grouping `g`, `K` correlated margins per level.

    Non-centered, from the scales `tau[1:K]` (drawn from their priors), the Cholesky factor of the margins' correlation `L ~ LKJCholesky(K, eta)` and standardized effects
    `z[1:length(levels(g)), 1:K] ~ Normal(0, 1)`. Returns the
    level-by-margin matrix `z * transpose(tau .* L)`, one row per level of `g` in order.
    """
    results = {}
    if any(name in outputs for name in ("value",)):
        value = z @ jnp.transpose(tau[..., None] * L)
    if "value" in outputs:
        results["value"] = value
    return results


def prepare_data(g: Any, g_fit: Any, x: ArrayLike, y: ArrayLike) -> dict:
    """The functions' data inputs, computed from the raw data once per dataset.

    Pass the data by the names the model reads them; a list of arrays is a ragged
    column. Call the other functions with the result: `f(u, **prepared)`.
    """
    g = np.asarray(g, dtype=object)
    g_fit = np.asarray(g_fit, dtype=object)
    x = np.asarray(x, dtype=np.float64)
    y = np.asarray(y, dtype=np.float64)
    X_mu = np.asarray(np.concatenate([np.ones((len(g),), dtype=np.float64)[:, None], x[:, None]], axis=1), dtype=np.float64)
    value = _brm_fit_levels_np(g_fit)
    g_fit_levels = value
    value_2 = _brm_level_indices_np(g, g_fit_levels)
    g_level = np.asarray(value_2, dtype=np.int64)
    ppl_axis1_b_mu_g_g_z = len(_rk_levels_np(g_fit_levels))
    ppl_last_b_mu_g_g_z = 4 + 2 * ppl_axis1_b_mu_g_g_z
    ppl_first_pop_mu_beta_pop = ppl_last_b_mu_g_g_z + 1
    ppl_last_pop_mu_beta_pop = ppl_first_pop_mu_beta_pop + 1
    return {"ppl_last_b_mu_g_g_z": StaticInt(ppl_last_b_mu_g_g_z), "ppl_axis1_b_mu_g_g_z": StaticInt(ppl_axis1_b_mu_g_g_z), "ppl_first_pop_mu_beta_pop": StaticInt(ppl_first_pop_mu_beta_pop), "ppl_last_pop_mu_beta_pop": StaticInt(ppl_last_pop_mu_beta_pop), "g_level": np.asarray(g_level, dtype=np.int64), "x": np.asarray(x, dtype=np.float64), "X_mu": np.asarray(X_mu, dtype=np.float64), "y": np.asarray(y, dtype=np.float64)}


def model(_entry: str, unconstrained: ArrayLike, **prepared: ArrayLike) -> Any:
    """Shared model computation. The generated entry wrappers select a static output."""
    ppl_last_b_mu_g_g_z = prepared["ppl_last_b_mu_g_g_z"]
    ppl_axis1_b_mu_g_g_z = prepared["ppl_axis1_b_mu_g_g_z"]
    ppl_first_pop_mu_beta_pop = prepared["ppl_first_pop_mu_beta_pop"]
    ppl_last_pop_mu_beta_pop = prepared["ppl_last_pop_mu_beta_pop"]
    g_level = prepared["g_level"]
    x = prepared["x"]
    X_mu = prepared["X_mu"]
    y = prepared["y"]
    unconstrained = jnp.asarray(unconstrained)
    g_level = jnp.asarray(g_level)
    x = jnp.asarray(x)
    X_mu = jnp.asarray(X_mu)
    y = jnp.asarray(y)
    if _entry in ("log_density", "log_prior", "log_likelihood", "constrain"):
        u_argument = unconstrained[0]
        constrain_2 = jnp.exp(u_argument)
        plate_argument = unconstrained[1:3]
        def b_mu_g_g_tau_cell(ppl_cell_b_mu_g_g_tau):
            constrain_3 = jnp.exp(ppl_cell_b_mu_g_g_tau)
            return constrain_3
        b_mu_g_g_tau = (jnp.zeros(plate_argument.shape[:1], dtype=jnp.float64) if 0 in plate_argument.shape[:1] else jax.vmap(b_mu_g_g_tau_cell, in_axes=(0,))(plate_argument))
    if _entry in ("log_density", "log_jacobian"):
        plate_argument_2 = unconstrained[1:3]
        def ppl_ljcells_b_mu_g_g_tau_cell(ppl_cell_b_mu_g_g_tau):
            return ppl_cell_b_mu_g_g_tau
        ppl_ljcells_b_mu_g_g_tau = (jnp.zeros(plate_argument_2.shape[:1], dtype=jnp.float64) if 0 in plate_argument_2.shape[:1] else jax.vmap(ppl_ljcells_b_mu_g_g_tau_cell, in_axes=(0,))(plate_argument_2))
    if _entry in ("log_density", "log_prior", "log_likelihood", "constrain"):
        pop_mu_beta_pop = unconstrained[ppl_first_pop_mu_beta_pop - 1:ppl_last_pop_mu_beta_pop]
        pop_mu = brm_population_effects(
            X=(X_mu if _entry in ("log_density", "log_likelihood", "constrain") else None),
            beta_pop=(pop_mu_beta_pop if _entry in ("log_density", "log_prior", "log_likelihood", "constrain") else None),
            outputs=tuple(
                name for name, needed in (
                    ("ppl_prior_beta_pop", ("log_density", "log_prior")),
                    ("ppl_pw_prior_beta_pop", ("log_density", "log_prior")),
                    ("value", ("log_density", "log_likelihood", "constrain")),
                )
                if _entry in needed
            ),
        )
    if _entry in ("log_density", "log_prior"):
        ppl_prior_sigma_log_scale = np.log(1.0)
        logpdf = jax.lax.cond(constrain_2 < 0, lambda: -jnp.inf, lambda: -ppl_prior_sigma_log_scale - constrain_2 / 1.0)
    if _entry in ("log_density", "log_jacobian"):
        u_argument_2 = unconstrained[0]
        plate_fold = jnp.sum(ppl_ljcells_b_mu_g_g_tau)
    b_mu_g_g = brm_correlated_group_effects_density(
        ppl_last_z=(ppl_last_b_mu_g_g_z if _entry in ("log_density", "log_prior", "log_likelihood", "constrain") else None),
        tau=(b_mu_g_g_tau if _entry in ("log_density", "log_prior") else None),
        unconstrained=unconstrained,
        outputs=tuple(
            name for name, needed in (
                ("ppl_arrflat_z", ("log_density", "log_prior", "log_likelihood", "constrain")),
                ("ppl_lkj_diagonal_L", ("log_density", "log_prior", "log_likelihood", "constrain")),
                ("ppl_lkj_partials_L", ("log_density", "log_prior", "log_likelihood", "log_jacobian", "constrain")),
                ("ppl_lkj_raw_L", ("log_density", "log_prior", "log_likelihood", "log_jacobian", "constrain")),
                ("ppl_prior_L", ("log_density", "log_prior")),
                ("ppl_prior_tau", ("log_density", "log_prior")),
                ("ppl_prior_z", ("log_density", "log_prior")),
                ("ppl_pw_prior_tau", ("log_density", "log_prior")),
                ("ppl_pw_prior_z", ("log_density", "log_prior")),
            )
            if _entry in needed
        ),
    )
    if _entry in ("log_density", "log_likelihood", "constrain"):
        ppl_lkj_lower = _ppl_lkj_lower(b_mu_g_g["ppl_lkj_partials_L"], b_mu_g_g["ppl_lkj_diagonal_L"], 2, 1)
        b_mu_g_g_L = ppl_lkj_lower
    if _entry in ("log_density", "log_jacobian"):
        total = 0.0
        tuple_ = (1, 2)
        i = tuple_[0]
        j = tuple_[1]
        def loop_body(p, carry):
            (i_2, j_2, total_2) = carry
            total_3 = total_2 + (j_2 - i_2 + 1) / 2 * jnp.log(1 - b_mu_g_g["ppl_lkj_partials_L"][p - 1] ** 2)
            tuple__2 = jax.lax.cond(i_2 + 1 < j_2, lambda: (i_2 + 1, j_2), lambda: (1, j_2 + 1))
            i_3 = tuple__2[0]
            j_3 = tuple__2[1]
            return (i_3, j_3, total_3)
        loop_carry = jax.lax.fori_loop(1, 2, loop_body, (jnp.asarray(i, dtype=jnp.int64), jnp.asarray(j, dtype=jnp.int64), jnp.asarray(total, dtype=jnp.float64)))
        ppl_lkj_logjac_b_mu_g_g_L = loop_carry[2]
    if _entry in ("log_density", "log_likelihood", "constrain"):
        b_mu_g_g_z = jnp.reshape(b_mu_g_g["ppl_arrflat_z"], (ppl_axis1_b_mu_g_g_z, 2), order="F")
    if _entry in ("log_density", "log_prior"):
        prior = logpdf + b_mu_g_g["ppl_prior_tau"] + b_mu_g_g["ppl_prior_L"] + b_mu_g_g["ppl_prior_z"] + pop_mu["ppl_prior_beta_pop"]
    if _entry in ("log_density", "log_jacobian"):
        log_jacobian_2 = u_argument_2 + plate_fold + ppl_lkj_logjac_b_mu_g_g_L
    if _entry in ("log_density", "log_likelihood", "constrain"):
        b_mu_g_g_2 = brm_correlated_group_effects(
            L=(b_mu_g_g_L if _entry in ("log_density", "log_likelihood", "constrain") else None),
            tau=(b_mu_g_g_tau if _entry in ("log_density", "log_likelihood", "constrain") else None),
            z=(b_mu_g_g_z if _entry in ("log_density", "log_likelihood", "constrain") else None),
            outputs=tuple(
                name for name, needed in (
                    ("value", ("log_density", "log_likelihood", "constrain")),
                )
                if _entry in needed
            ),
        )
        ranef_mu_mu_g_g = b_mu_g_g_2["value"][g_level - 1, 0] + b_mu_g_g_2["value"][g_level - 1, 1] * x
        ppl_offset_mu = pop_mu["value"] + ranef_mu_mu_g_g
    if _entry in ("log_density", "log_likelihood"):
        def ppl_pw_y_resp_cell(y_2, mu, sigma):
            def then_arm():
                log_scale = jnp.log(sigma)
                standardized = (y_2 - mu) / jnp.where(jnp.logical_and(sigma == 0, y_2 == mu), 1.0, sigma)
                standard_logpdf = -0.5 * np.log(2 * np.pi) - 0.5 * standardized ** 2
                return standard_logpdf - jnp.where(jnp.logical_and(sigma == 0, y_2 != mu), 0.0, log_scale)
            ppl_density = jax.lax.cond(sigma > 0, then_arm, lambda: -jnp.inf)
            return ppl_density
        ppl_pw_y_resp = (jnp.zeros(y.shape[:1], dtype=jnp.float64) if 0 in y.shape[:1] and ppl_offset_mu.shape[:1] == y.shape[:1] else jax.vmap(ppl_pw_y_resp_cell, in_axes=(0, 0, None))(y, ppl_offset_mu, constrain_2))
        ppl_lik_y_resp = jnp.sum(ppl_pw_y_resp)
    if _entry in ("log_density",):
        posterior = prior + ppl_lik_y_resp + log_jacobian_2
    if not (unconstrained.size == ppl_last_pop_mu_beta_pop):
        raise ValueError("[layout] packed length ≠ layout total: a packed point holds the coordinates of the binding whose layout packed it")
    if _entry == "log_density":
        return jnp.asarray(posterior, dtype=jnp.float64)
    if _entry == "log_prior":
        return jnp.asarray(prior, dtype=jnp.float64)
    if _entry == "log_likelihood":
        return jnp.asarray(ppl_lik_y_resp, dtype=jnp.float64)
    if _entry == "log_jacobian":
        return jnp.asarray(log_jacobian_2, dtype=jnp.float64)
    if _entry == "constrain":
        return {"sigma": jnp.asarray(constrain_2, dtype=jnp.float64), "b_mu__g_g": {"tau": jnp.asarray(b_mu_g_g_tau), "L": jnp.asarray(b_mu_g_g_L), "z": jnp.asarray(b_mu_g_g_z)}, "pop_mu": {"beta_pop": jnp.asarray(pop_mu_beta_pop)}, "mu": jnp.asarray(ppl_offset_mu)}


def log_density(unconstrained: ArrayLike, **prepared: ArrayLike) -> jax.Array:
    """The log density a sampler targets at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`.

    The sum of `log_prior`, `log_likelihood` and `log_jacobian`.
    """
    return model("log_density", unconstrained, **prepared)


def log_prior(unconstrained: ArrayLike, **prepared: ArrayLike) -> jax.Array:
    """The log prior density of the constrained parameters at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`."""
    return model("log_prior", unconstrained, **prepared)


def log_likelihood(unconstrained: ArrayLike, **prepared: ArrayLike) -> jax.Array:
    """The log likelihood of the observations at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`."""
    return model("log_likelihood", unconstrained, **prepared)


def log_jacobian(unconstrained: ArrayLike, **prepared: ArrayLike) -> jax.Array:
    """The log Jacobian of the constraining transforms at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`."""
    return model("log_jacobian", unconstrained, **prepared)


def constrain(unconstrained: ArrayLike, **prepared: ArrayLike) -> dict:
    """The constrained value of each parameter, and of each requested value, at `unconstrained`, the packed unconstrained parameters (length `dimension(prepared)`), for the data `prepare_data` returned: `f(u, **prepared)`. Returns a dict, a submodel's values nested under its name:

    - `sigma`: Residual scale of the response.
    - `b_mu__g_g.tau`
    - `b_mu__g_g.L`
    - `b_mu__g_g.z`
    - `pop_mu.beta_pop`
    - `mu`: Expected response: a population line, and each group's own intercept and slope, correlated.
    """
    return model("constrain", unconstrained, **prepared)


def dimension(prepared: dict) -> int:
    """The length of `unconstrained` for the data `prepared` (what `prepare_data` returned)."""
    return int(prepared["ppl_last_pop_mu_beta_pop"])


def parameters(prepared: dict) -> dict:
    """Each parameter's 0-based `start`/`stop` in `unconstrained`, its transform and dimensions,
    for the data `prepared` (what `prepare_data` returned)."""
    return {"sigma": {"start": 0, "stop": 1, "transform": "exp", "dims": ()}, "b_mu__g_g.tau": {"start": 1, "stop": 3, "transform": "exp", "dims": (2,)}, "b_mu__g_g.L": {"start": 3, "stop": 4, "transform": "lkj", "dims": (2, 2)}, "b_mu__g_g.z": {"start": 4, "stop": int(prepared["ppl_last_b_mu_g_g_z"]), "transform": "identity", "dims": (int(prepared["ppl_axis1_b_mu_g_g_z"]), 2)}, "pop_mu.beta_pop": {"start": int(prepared["ppl_first_pop_mu_beta_pop"]) - 1, "stop": int(prepared["ppl_last_pop_mu_beta_pop"]), "transform": "identity", "dims": (2,)}}
