{"key":"s4-uncertainty-tail","approach":"For spread 4 only, use the lower 20% quantile of the existing nine-point retail-size posterior, conditional on the unchanged point rate estimate. For exposure E<200, scale only new desired ask size by 1-(1-E/200)*(1-min(posterior_mean,q20)/posterior_mean); subtract kept ask quantity and floor at zero. Existing ask retention, posterior learning, stock demand, bids and other spread branches retain incumbent formulas. This is a conditional credible flow quantile, not a joint posterior over arrival rate and size.","tried":[{"variant":"conditional-q20-linear-exposure200","code_sha256":"120ca4121b17c5b56982d8c6258d9edf1db9985e3119eb66d7b0d956629f2d63","target_spreads":[4],"selection":"Only one variant tested; frozen before holdout; no holdout-driven edits.","tuning_score":{"n":200,"sum_d":7.9187467026000995,"sum_d2":91.26159726900839,"mean_diff":0.039593733513000495,"se":0.04780300460540361,"C_mean_edge":85.202246898555,"B_mean_edge":85.16265316504199,"retail_diff":0.008119149331000362,"arb_diff":0.03147458418500005}}],"next":"Do not promote: holdout gain is only about 1.22 SE. Retain this small isolated candidate at low priority; if independently replicated, extend on additional permitted seeds before any finalist decision. No finalist seeds were used.","code":"\"\"\"Exact per-spread merge: c1-pairs, c2-queue, a3-ledger, c4-all; no fixes.\"\"\"\nimport math\nfrom orderbook_pm_challenge.strategy import BaseStrategy\nfrom orderbook_pm_challenge.types import CancelOrder, PlaceOrder, Side\n\ndef _spread1():\n    P = dict(lam_r=0.25, m=5.0, sig_n=1.2, lam_j=0.0019, sig_j=0.35, sig=0.02, qmax=3000.0, rmin=2, kA=0.7, kL=0.15, pL=0.05, ammo=1.0, ydem=0.4, W=200.0, fy=0.6, ammo_q=60.0, ammo_pmax=0.05, ammo_maxpay=0.02, fb=0.9, fu=0.7, xu=0.1, sticky=1.0, min_ahead=2.0, keep_hi=1.5, keep_lo=0.7, Hu=300.0, bins=8.0, filt=1.0, uni=0.01, jumpinfo=1.0, dmin=0.0, kLb=0.08, kLf=0.08, pinf=1.0, pre=0.0, H1=100.0, ydf=0.6, Wf=2000.0, g_hi=0.15, g_lo=0.15, qf=400.0, pmaxf=0.05, pre_gap=1.0, ydf1=0.6, g1=5.0, f1=0.6, a1=100.0, nb1=0.0, gs=1.0, p1t=1.0, m1=1.0, zd=1.0, pfl=0.0005)\n    SQ2 = math.sqrt(2.0)\n    SQ2PI = math.sqrt(2.0 * math.pi)\n\n    def cdf(x):\n        return 0.5 * (1.0 + math.erf(x / SQ2))\n\n    def pdf(x):\n        return math.exp(-0.5 * x * x) / SQ2PI\n\n    def inv(p):\n        p = min(max(p, 1e-09), 1 - 1e-09)\n        t = math.sqrt(-2.0 * math.log(min(p, 1 - p)))\n        x = t - (2.515517 + 0.802853 * t + 0.010328 * t * t) / (1 + 1.432788 * t + 0.189269 * t * t + 0.001308 * t ** 3)\n        x = -x if p < 0.5 else x\n        for _ in range(2):\n            d = pdf(x)\n            if d < 1e-12:\n                break\n            x -= (cdf(x) - p) / d\n        return x\n\n    def lpm(k):\n        return pdf(k) + k * cdf(k)\n\n    def fl(q):\n        return math.floor(q * 100 + 1e-09) / 100\n    NODES = [(-2.2, 0.06), (-1.3, 0.17), (-0.6, 0.27), (0.6, 0.27), (1.3, 0.17), (2.2, 0.06)]\n    PROBE = 0.01\n    F_AH = 1\n    F_FL = 1\n    F_QB = 1\n    F_LK = 0\n    F_SB = 0\n    FLOW_CAPS = (0.03125, 0.0625, 0.125, 0.25, 0.5, 1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0, 128.0, 256.0)\n    FLOW_GRID = []\n    FLOW_PRIORS = []\n    for _rn, _rw in ((-math.sqrt(0.6), 5 / 18), (0.0, 4 / 9), (math.sqrt(0.6), 5 / 18)):\n        _r = 0.1265 + 0.0495 * _rn\n        for _mn, _mw in ((-0.906179845938664, 0.118463442528095), (-0.538469310105683, 0.239314335249683), (0.0, 0.284444444444444), (0.538469310105683, 0.239314335249683), (0.906179845938664, 0.118463442528095)):\n            _m = 4.488 + 1.848 * _mn\n            _parts = []\n            for _n in (1, 2, 3):\n                _v = math.log(1 + (math.exp(1.44) - 1) / _n)\n                _sg = math.sqrt(_v)\n                _mu = math.log(_n * _m) - _v / 2\n                _w = _r ** _n / math.factorial(_n)\n                _parts.append((_mu, _sg, _w))\n            _norm = []\n            for _c in FLOW_CAPS:\n                _prob = sum((w * (cdf((math.log(_c) - mu) / sg) - cdf((math.log(0.03) - mu) / sg)) for mu, sg, w in _parts))\n                _norm.append(math.log1p(_prob))\n            _tails = []\n            for _c in FLOW_CAPS:\n                _cdf = 1 + sum((w * cdf((math.log(_c) - mu) / sg) for mu, sg, w in _parts))\n                _tails.append(math.log(max(1e-100, 1 - math.exp(-_r) * _cdf)))\n            FLOW_GRID.append((_r, _m, _parts, _norm, _tails))\n            FLOW_PRIORS.append(math.log(_rw * _mw))\n    return (P, cdf, pdf, inv, lpm, fl, NODES, PROBE, F_AH, F_FL, F_QB, F_LK, F_SB, FLOW_CAPS, FLOW_GRID, FLOW_PRIORS)\n\ndef _spread2():\n    P = dict(lam_r=0.25, m=5.0, sig_n=1.2, lam_j=0.0019, sig_j=0.35, sig=0.02, qmax=3000.0, rmin=2, kA=0.7, kL=0.15, pL=0.05, ammo=1.0, ydem=0.4, W=200.0, fy=0.6, ammo_q=60.0, ammo_pmax=0.05, ammo_maxpay=0.02, fb=0.9, fu=0.7, xu=0.1, sticky=1.0, min_ahead=2.0, keep_hi=1.5, keep_lo=0.7, Hu=300.0, bins=8.0, filt=1.0, uni=0.01, jumpinfo=1.0, dmin=0.0, kLb=0.08, kLf=0.08, pinf=1.0, pre=0.0, H1=100.0, ydf=0.6, Wf=2000.0, g_hi=0.15, g_lo=0.15, qf=400.0, pmaxf=0.05, pre_gap=1.0, ydf1=0.6, g1=5.0, f1=0.6, a1=100.0, nb1=0.0, gs=1.0, p1t=1.0, m1=1.0, zd=1.0, pfl=0.0005)\n    SQ2 = math.sqrt(2.0)\n    SQ2PI = math.sqrt(2.0 * math.pi)\n\n    def cdf(x):\n        return 0.5 * (1.0 + math.erf(x / SQ2))\n\n    def pdf(x):\n        return math.exp(-0.5 * x * x) / SQ2PI\n\n    def inv(p):\n        p = min(max(p, 1e-09), 1 - 1e-09)\n        t = math.sqrt(-2.0 * math.log(min(p, 1 - p)))\n        x = t - (2.515517 + 0.802853 * t + 0.010328 * t * t) / (1 + 1.432788 * t + 0.189269 * t * t + 0.001308 * t ** 3)\n        x = -x if p < 0.5 else x\n        for _ in range(2):\n            d = pdf(x)\n            if d < 1e-12:\n                break\n            x -= (cdf(x) - p) / d\n        return x\n\n    def lpm(k):\n        return pdf(k) + k * cdf(k)\n\n    def fl(q):\n        return math.floor(q * 100 + 1e-09) / 100\n    NODES = [(-2.2, 0.06), (-1.3, 0.17), (-0.6, 0.27), (0.6, 0.27), (1.3, 0.17), (2.2, 0.06)]\n    PROBE = 0.01\n    return (P, cdf, pdf, inv, lpm, fl, NODES, PROBE)\n\ndef _spread3():\n    P = dict(lam_r=0.25, m=5.0, sig_n=1.2, lam_j=0.0019, sig_j=0.35, sig=0.02, qmax=3000.0, rmin=2, kA=0.7, kL=0.15, pL=0.05, ammo=1.0, ydem=0.4, W=200.0, fy=0.6, ammo_q=60.0, ammo_pmax=0.05, ammo_maxpay=0.02, fb=0.9, fu=0.7, xu=0.1, sticky=1.0, min_ahead=2.0, keep_hi=1.5, keep_lo=0.7, Hu=300.0, bins=8.0, filt=1.0, uni=0.01, jumpinfo=1.0, dmin=0.0, kLb=0.08, kLf=0.08, pinf=1.0, pre=0.0, H1=100.0, ydf=0.6, Wf=2000.0, g_hi=0.15, g_lo=0.15, qf=400.0, pmaxf=0.05, pre_gap=1.0, ydf1=0.6, g1=5.0, f1=0.6, a1=100.0, nb1=0.0, gs=1.0, p1t=1.0, m1=1.0, zd=1.0, pfl=0.0005)\n    SQ2 = math.sqrt(2.0)\n    SQ2PI = math.sqrt(2.0 * math.pi)\n\n    def cdf(x):\n        return 0.5 * (1.0 + math.erf(x / SQ2))\n\n    def pdf(x):\n        return math.exp(-0.5 * x * x) / SQ2PI\n\n    def inv(p):\n        p = min(max(p, 1e-09), 1 - 1e-09)\n        t = math.sqrt(-2.0 * math.log(min(p, 1 - p)))\n        x = t - (2.515517 + 0.802853 * t + 0.010328 * t * t) / (1 + 1.432788 * t + 0.189269 * t * t + 0.001308 * t ** 3)\n        x = -x if p < 0.5 else x\n        for _ in range(2):\n            d = pdf(x)\n            if d < 1e-12:\n                break\n            x -= (cdf(x) - p) / d\n        return x\n\n    def lpm(k):\n        return pdf(k) + k * cdf(k)\n\n    def fl(q):\n        return math.floor(q * 100 + 1e-09) / 100\n    NODES = [(-2.2, 0.06), (-1.3, 0.17), (-0.6, 0.27), (0.6, 0.27), (1.3, 0.17), (2.2, 0.06)]\n    PROBE = 0.01\n    return (P, cdf, pdf, inv, lpm, fl, NODES, PROBE)\n\ndef _spread4():\n    P = dict(lam_r=0.25, m=5.0, sig_n=1.2, lam_j=0.0019, sig_j=0.35, sig=0.02, qmax=3000.0, rmin=2, kA=0.7, kL=0.15, pL=0.05, ammo=1.0, ydem=0.4, W=200.0, fy=0.6, ammo_q=60.0, ammo_pmax=0.05, ammo_maxpay=0.02, fb=0.9, fu=0.7, xu=0.1, sticky=1.0, min_ahead=2.0, keep_hi=1.5, keep_lo=0.7, Hu=300.0, bins=8.0, filt=1.0, uni=0.01, jumpinfo=1.0, dmin=0.0, kLb=0.08, kLf=0.08, pinf=1.0, pre=0.0, H1=100.0, ydf=0.6, Wf=2000.0, g_hi=0.15, g_lo=0.15, qf=400.0, pmaxf=0.05, pre_gap=1.0, ydf1=0.6, g1=5.0, f1=0.6, a1=100.0, nb1=0.0, gs=1.0, p1t=1.0, m1=1.0, zd=1.0, pfl=0.0005)\n    SQ2 = math.sqrt(2.0)\n    SQ2PI = math.sqrt(2.0 * math.pi)\n\n    def cdf(x):\n        return 0.5 * (1.0 + math.erf(x / SQ2))\n\n    def pdf(x):\n        return math.exp(-0.5 * x * x) / SQ2PI\n\n    def inv(p):\n        p = min(max(p, 1e-09), 1 - 1e-09)\n        t = math.sqrt(-2.0 * math.log(min(p, 1 - p)))\n        x = t - (2.515517 + 0.802853 * t + 0.010328 * t * t) / (1 + 1.432788 * t + 0.189269 * t * t + 0.001308 * t ** 3)\n        x = -x if p < 0.5 else x\n        for _ in range(2):\n            d = pdf(x)\n            if d < 1e-12:\n                break\n            x -= (cdf(x) - p) / d\n        return x\n\n    def lpm(k):\n        return pdf(k) + k * cdf(k)\n\n    def fl(q):\n        return math.floor(q * 100 + 1e-09) / 100\n    NODES = [(-2.2, 0.06), (-1.3, 0.17), (-0.6, 0.27), (0.6, 0.27), (1.3, 0.17), (2.2, 0.06)]\n    PROBE = 0.01\n    return (P, cdf, pdf, inv, lpm, fl, NODES, PROBE)\n\nclass Strategy(BaseStrategy):\n\n    def __init__(self):\n        self.n = 0\n        self.ahead = set()\n        self.res = {}\n        self.bc = None\n        self.bw = None\n        self.st = 0.5\n        self.pcb = self.pca = None\n        self.pb = set()\n        self.pa = set()\n        self.tb = 0\n        self.s = None\n        self.flow_notional = 0.0\n        self.flow_exposure = 0\n        self.last_ask_tick = None\n        self.last_quote_exposed = False\n        self.last_flow_ca = None\n        self.last_flow_cap = 0.0\n        self.last_flow_correction = 1.0\n        self.params = None\n\n    def _oid(self, tag):\n        self.n += 1\n        return tag + str(self.n)\n\n    def on_step(self, state):\n        H = max(1, state.steps_remaining)\n        cb = state.competitor_best_bid_ticks or 0\n        ca = state.competitor_best_ask_ticks or 100\n        initializing = self.s is None\n        if initializing:\n            self.s = max(1, (ca - cb + 1) // 2)\n            if self.s == 1:\n                self._scope = _spread1()\n            elif self.s == 2:\n                self._scope = _spread2()\n            elif self.s == 3:\n                self._scope = _spread3()\n            elif self.s == 4:\n                self._scope = _spread4()\n            self.params = self._scope[0].copy()\n        if self.s == 1:\n            _unused, cdf, pdf, inv, lpm, fl, NODES, PROBE, F_AH, F_FL, F_QB, F_LK, F_SB, FLOW_CAPS, FLOW_GRID, FLOW_PRIORS = self._scope\n        elif self.s == 2:\n            _unused, cdf, pdf, inv, lpm, fl, NODES, PROBE = self._scope\n        elif self.s == 3:\n            _unused, cdf, pdf, inv, lpm, fl, NODES, PROBE = self._scope\n        elif self.s == 4:\n            _unused, cdf, pdf, inv, lpm, fl, NODES, PROBE = self._scope\n        if initializing:\n            if self.s == 1:\n                self.fl_obs = ()\n                self.fl_scores = FLOW_PRIORS.copy()\n                self.fl_bins = [0] * len(FLOW_CAPS)\n                self.fl_rate = 0.568734\n                self.fl_r = 0.1265\n                self.fl_m = 4.488\n                self.fl_buy_sum = self.fl_sell_sum = 0.0\n                self.fl_buy_exp = self.fl_sell_exp = 0.0\n                self.fl_exp = 0\n                self.fl_dirty = False\n                self.fl_ahead = set()\n                self.fl_safe_n = 0\n                self.fl_sbins = [0] * len(FLOW_CAPS)\n            elif self.s == 2:\n                self.params.update(dict(flow_prior=200, flow_level=0.6, flow_strength=1.0, flow_safety=2.0, flow_exposure_min=5.0))\n                self.params.update({'kLf': 0.16})\n            elif self.s == 4:\n                self.f4_exposure = [0, 0]\n                self.f4_events = [0, 0]\n                self.f4_weights = [[0.0] * 9, [0.0] * 9]\n                self.f4_means = [2.64 + i * (6.336 - 2.64) / 8 for i in range(9)]\n                self.f4_mu = [math.log(m) - 0.72 + 0.065 for m in self.f4_means]\n                self.f4_last = [None, None]\n                self.f4_rate = 0.1265\n                self.f4_mean = 4.488\n                self.f4_ask_lower_mean = self.f4_means[1]\n                self.f4_flow = self.f4_rate * self.f4_mean\n                self.f4_extreme = inv(1 - 1e-06)\n            if self.s == 1:\n                self.params.update({'dmin': 0.3, 'pfl': 1e-06})\n            if self.s == 3:\n                self.params.update({'flow_prior': 200, 'flow_level': 0.6, 'flow_strength': 1.0, 'flow_safety': 2.0, 'flow_exposure_min': 5.0})\n        P = self.params\n        if self.s == 1:\n            s1 = self.s == 1\n            AH = s1 and F_AH\n            FL = s1 and F_FL\n            QB = s1 and F_QB\n            LK = s1 and F_LK\n            SB = s1 and F_SB\n        elif self.s == 2:\n            if self.last_quote_exposed and ca <= self.last_flow_ca + 1:\n                self.flow_exposure += 1\n                self.flow_notional += min(self.last_flow_cap, state.sell_filled_quantity * self.last_ask_tick / 100.0) * self.last_flow_correction\n        elif self.s == 3:\n            if self.last_quote_exposed and ca <= self.last_flow_ca + 1:\n                self.flow_exposure += 1\n                self.flow_notional += min(self.last_flow_cap, state.sell_filled_quantity * self.last_ask_tick / 100.0) * self.last_flow_correction\n        elif self.s == 4:\n            for side, filled, bound in ((0, state.sell_filled_quantity, ca), (1, state.buy_filled_quantity, cb)):\n                last = self.f4_last[side]\n                if last is None:\n                    continue\n                tick, conv, cap, old_bound, ids = last\n                if side == 0 and bound > old_bound + 1 or (side == 1 and bound < old_bound - 1):\n                    continue\n                remaining = sum((o.remaining_quantity for o in state.own_orders if o.order_id in ids))\n                value = max(0.0, cap - remaining * conv)\n                self.f4_exposure[side] += 1\n                if value > 0.01:\n                    self.f4_events[side] += 1\n                    censored = remaining < 0.011\n                    logv = math.log(max(value, 0.01))\n                    weights = self.f4_weights[side]\n                    for i, mu4 in enumerate(self.f4_mu):\n                        z4 = (logv - mu4) / 1.2\n                        weights[i] += math.log(max(1e-12, 1.0 - cdf(z4))) if censored else -0.5 * z4 * z4\n            if state.step % 25 == 0:\n                exposure = sum(self.f4_exposure)\n                events = sum(self.f4_events)\n                event_probability = (events + 80.0 * (1.0 - math.exp(-0.1265))) / (exposure + 80.0)\n                self.f4_rate = max(0.077, min(0.176, -math.log(max(1e-06, 1.0 - event_probability))))\n                weights = [a + b for a, b in zip(*self.f4_weights)]\n                peak = max(weights)\n                weights = [math.exp(w - peak) for w in weights]\n                self.f4_mean = sum((m * w for m, w in zip(self.f4_means, weights))) / sum(weights)\n                self.f4_flow = self.f4_rate * self.f4_mean\n                cumulative = 0.0\n                for mean4, weight4 in zip(self.f4_means, weights):\n                    cumulative += weight4\n                    if cumulative >= 0.20 * sum(weights):\n                        self.f4_ask_lower_mean = min(self.f4_mean, mean4)\n                        break\n        lo, hi = (cb, ca)\n        for o in state.own_orders:\n            if o.side is Side.BUY:\n                lo = max(lo, o.price_ticks)\n            else:\n                hi = min(hi, o.price_ticks)\n        if P['pinf'] > 0:\n            sb = {o.price_ticks for o in state.own_orders if o.side is Side.BUY and o.remaining_quantity <= PROBE + 1e-09}\n            sa = {o.price_ticks for o in state.own_orders if o.side is Side.SELL and o.remaining_quantity <= PROBE + 1e-09}\n            ea = self.pa - sa\n            eb = self.pb - sb\n            if sa and ea:\n                lo = max(lo, min(max(ea), hi))\n            if eb and (sb or min(eb) <= P['p1t']):\n                hi = min(hi, max(min(eb), lo))\n        if P['jumpinfo'] > 0 and self.pcb is not None:\n            if ca > self.pca + 1:\n                lo = max(lo, ca - 1)\n            if cb < self.pcb - 1:\n                hi = min(hi, cb + 1)\n        self.pcb, self.pca = (cb, ca)\n        if lo > hi:\n            lo, hi = (hi, lo)\n        wid = max(hi - lo, 1e-06)\n        nb = max(2, min(48, int(round(wid * P['bins']))))\n        cs = [lo + (i + 0.5) * wid / nb for i in range(nb)]\n        if self.bc is None or P['filt'] <= 0:\n            ws = [1.0 / nb] * nb\n        else:\n            sg = max(self.st, 0.6 * wid / nb)\n            k = -0.5 / (sg * sg)\n            ws = []\n            uni = P['uni'] * sg\n            if self.s == 1:\n                prior = tuple(zip(self.bc, self.bw))\n                exp = math.exp\n                for c in cs:\n                    t = uni\n                    for ci, wi in prior:\n                        d = c - ci\n                        d2 = d * d * k\n                        if d2 > -12.5:\n                            t += wi * exp(d2)\n                    ws.append(t)\n            elif self.s == 2:\n                for c in cs:\n                    t = uni\n                    for ci, wi in zip(self.bc, self.bw):\n                        d = c - ci\n                        d2 = d * d * k\n                        if d2 > -12.5:\n                            t += wi * math.exp(d2)\n                    ws.append(t)\n            elif self.s == 3:\n                for c in cs:\n                    t = uni\n                    for ci, wi in zip(self.bc, self.bw):\n                        d = c - ci\n                        d2 = d * d * k\n                        if d2 > -12.5:\n                            t += wi * math.exp(d2)\n                    ws.append(t)\n            elif self.s == 4:\n                exp = math.exp\n                if self.bc == cs and 1.0 <= wid <= 6.0 and (nb == 8 * wid):\n                    kernel = []\n                    c0 = cs[0]\n                    for ci in self.bc:\n                        d = c0 - ci\n                        d2 = d * d * k\n                        kernel.append(exp(d2) if d2 > -12.5 else 0.0)\n                    kernel = kernel[:0:-1] + kernel\n                    for i in range(nb):\n                        t = uni\n                        start = nb - 1 - i\n                        for wi, e in zip(self.bw, kernel[start:start + nb]):\n                            if e:\n                                t += wi * e\n                        ws.append(t)\n                else:\n                    previous = tuple(zip(self.bc, self.bw))\n                    for c in cs:\n                        t = uni\n                        for ci, wi in previous:\n                            d = c - ci\n                            d2 = d * d * k\n                            if d2 > -12.5:\n                                t += wi * exp(d2)\n                        ws.append(t)\n            tot = sum(ws)\n            ws = [w / tot for w in ws]\n        self.bc, self.bw = (cs, ws)\n        mean_t = sum((c * w for c, w in zip(cs, ws)))\n        var_t = max(sum((c * c * w for c, w in zip(cs, ws))) - mean_t * mean_t, 0.0)\n        phat = min(max(mean_t / 100.0, 0.002), 0.998)\n        var = P['sig'] ** 2 + P['lam_j'] * P['sig_j'] ** 2\n        sd = math.sqrt(H * var)\n        self.tb = self.tb + 1 if hi <= 1 else 0\n        if self.tb > 0 and P['zd'] > 0:\n            phat = min(phat, max(P['pfl'], cdf(inv(0.01) - P['zd'] * 0.02 * math.sqrt(self.tb) / sd)))\n        z = inv(phat)\n        Z = z * sd\n        sp = pdf(z) / sd * P['sig']\n        self.st = sp * 100.0\n        if self.s == 1:\n            if FL:\n                remaining = {o.order_id: o.remaining_quantity for o in state.own_orders} if self.fl_obs else {}\n                for px, ci, buying, previous, tick in self.fl_obs:\n                    qty = max(0.0, sum((q - remaining.get(oid, 0.0) for oid, q in previous)))\n                    x = qty * px\n                    cap = FLOW_CAPS[ci]\n                    gap = tick / 100.0 - phat if buying else phat - tick / 100.0\n                    safe = gap > max(0.005, 2.0 * math.sqrt(var_t) / 100.0)\n                    if 0 < x < 0.03:\n                        continue\n                    if x >= cap:\n                        if safe:\n                            self.fl_sbins[ci] += 1\n                            self.fl_exp += 1\n                            self.fl_dirty = True\n                        continue\n                    if safe:\n                        self.fl_safe_n += 1\n                    else:\n                        self.fl_bins[ci] += 1\n                    self.fl_exp += 1\n                    self.fl_dirty = True\n                    if buying:\n                        self.fl_buy_exp += 1\n                    else:\n                        self.fl_sell_exp += 1\n                    if x > 0:\n                        lx = math.log(x)\n                        for i, (r, m, parts, norm, tails) in enumerate(FLOW_GRID):\n                            density = sum((w * pdf((lx - mu) / sg) / sg for mu, sg, w in parts))\n                            self.fl_scores[i] += math.log(max(density, 1e-100))\n                if state.step % 100 == 0 and (self.fl_dirty or state.step == 0):\n                    bins = [(i, n) for i, n in enumerate(self.fl_bins) if n]\n                    sbins = [(i, n) for i, n in enumerate(self.fl_sbins) if n]\n                    logs = [score - sum((n * g[3][i] for i, n in bins)) - g[0] * self.fl_safe_n + sum((n * g[4][i] for i, n in sbins)) for score, g in zip(self.fl_scores, FLOW_GRID)]\n                    mx = max(logs)\n                    weights = [math.exp(v - mx) for v in logs]\n                    den = sum(weights)\n                    self.fl_dirty = False\n                    self.fl_rate = sum((w * g[0] * g[1] for w, g in zip(weights, FLOW_GRID))) / den\n                    self.fl_r = sum((w * g[0] for w, g in zip(weights, FLOW_GRID))) / den\n                    self.fl_m = sum((w * g[1] for w, g in zip(weights, FLOW_GRID))) / den\n            s = math.sqrt(sp * sp + var_t / 10000.0 + 1e-08)\n        s = math.sqrt(sp * sp + var_t / 10000.0 + 1e-08)\n        sd1 = math.sqrt(max(1.0, H - 1.0) * var)\n        jp = [(cdf((Z + n * P['sig_j']) / sd1), w) for n, w in NODES]\n        lj = P['lam_j']\n\n        def AB(x):\n            k = (x - phat) / s\n            a = s * lpm(k)\n            b = a - (x - phat)\n            if self.s == 1:\n                ja = sum((w * max(0.0, x - p) for p, w in jp))\n                jb = sum((w * max(0.0, p - x) for p, w in jp))\n            elif self.s == 2:\n                ja = sum((w * max(0.0, x - p) for p, w in jp))\n                jb = sum((w * max(0.0, p - x) for p, w in jp))\n            elif self.s == 3:\n                ja = sum((w * max(0.0, x - p) for p, w in jp))\n                jb = sum((w * max(0.0, p - x) for p, w in jp))\n            elif self.s == 4:\n                ja = jb = 0.0\n                for p, w in jp:\n                    if x > p:\n                        ja += w * (x - p)\n                    else:\n                        jb += w * (p - x)\n            return ((1 - lj) * a + lj * ja, (1 - lj) * b + lj * jb)\n        if H == 1:\n\n            def AB(x):\n                return ((1 - phat) * x, phat * (1 - x))\n        rho = P['lam_r'] * 0.5\n        mu = math.log(P['m']) - 0.5 * P['sig_n'] ** 2\n        kA = P['kL'] if phat < P['pL'] else P['kA']\n        if self.s == 1:\n\n            def qsize(loss, gain, px, flow=False, cap=None):\n                loss *= kA\n                if gain <= 0:\n                    return 0.0\n                rr = 0.125 + 0.5 * (self.fl_r - 0.125) if flow and FL else rho\n                mm = math.log(5.0 + 0.5 * (self.fl_m - 5.0)) - 0.5 * P['sig_n'] ** 2 if flow and FL else mu\n                tail = loss / (rr * gain)\n                if tail >= 1.0:\n                    return 0.0\n                return min(cap if cap is not None else P['qmax'], math.exp(mm + P['sig_n'] * inv(1 - max(tail, 1e-06))) / px)\n        elif self.s == 2:\n\n            def qsize(loss, gain, px):\n                loss *= kA\n                if gain <= 0:\n                    return 0.0\n                tail = loss / (rho * gain)\n                if tail >= 1.0:\n                    return 0.0\n                return min(P['qmax'], math.exp(mu + P['sig_n'] * inv(1 - max(tail, 1e-06))) / px)\n        elif self.s == 3:\n\n            def qsize(loss, gain, px):\n                loss *= kA\n                if gain <= 0:\n                    return 0.0\n                tail = loss / (rho * gain)\n                if tail >= 1.0:\n                    return 0.0\n                return min(P['qmax'], math.exp(mu + P['sig_n'] * inv(1 - max(tail, 1e-06))) / px)\n        elif self.s == 4:\n\n            def qsize(loss, gain, px):\n                loss *= kA\n                if gain <= 0:\n                    return 0.0\n                tail = loss / (rho * gain)\n                if tail >= 1.0:\n                    return 0.0\n                if tail <= 1e-06:\n                    return min(P['qmax'], math.exp(mu + P['sig_n'] * self.f4_extreme) / px)\n                return min(P['qmax'], math.exp(mu + P['sig_n'] * inv(1 - max(tail, 1e-06))) / px)\n        ptk = phat * 100\n\n        def qbid(t):\n            if not 1 <= t <= 99:\n                return 0.0\n            if self.s == 4:\n                if phat * 100 - t < P['dmin']:\n                    return 0.0\n            a, b = AB(t / 100.0)\n            if phat * 100 - t < P['dmin']:\n                return 0.0\n            if P['nb1'] > 0 and self.s == 1 and (t == 1) and (ptk < 1.0):\n                return 0.0\n            if phat < P['pL']:\n                ytg = P['ydem'] * min(H, P['W']) / max(ca - 1, ptk + 1) * 100.0\n                a *= (P['kLb'] if state.yes_inventory < ytg else P['kLf']) / P['kL']\n            return qsize(a, b, max(phat, 0.05))\n\n        def qask(t):\n            if not 1 <= t <= 99:\n                return 0.0\n            if self.s == 4:\n                if t - phat * 100 < P['dmin']:\n                    return 0.0\n            a, b = AB(t / 100.0)\n            if t - phat * 100 < P['dmin']:\n                return 0.0\n            if self.s == 1:\n                return qsize(b, a, t / 100.0, flow=True, cap=15000 if AH and t == 2 and (phat < 0.01) else None)\n            elif self.s == 2:\n                return qsize(b, a, t / 100.0)\n            elif self.s == 3:\n                return qsize(b, a, t / 100.0)\n            elif self.s == 4:\n                if P['pL'] <= phat <= 0.95:\n                    b *= 1.4\n                tail = b * kA / max(self.f4_rate * a, 1e-30)\n                if a <= 0 or tail >= 1.0:\n                    return 0.0\n                return min(P['qmax'], math.exp(math.log(self.f4_mean) - 0.72 + 1.2 * (self.f4_extreme if tail <= 1e-06 else inv(1 - tail))) / (t / 100.0))\n                return qsize(b, a, t / 100.0)\n        bids = [o for o in state.own_orders if o.side is Side.BUY and o.remaining_quantity > PROBE + 1e-09]\n        asks = [o for o in state.own_orders if o.side is Side.SELL and o.remaining_quantity > PROBE + 1e-09]\n        sticky = P['sticky'] > 0\n        if self.s == 4:\n            ma_ask = 50.0 if self.s == 4 and phat < 0.05 else P['min_ahead']\n\n        def top(orders, comp, step):\n            if self.s == 1:\n                if sticky and sum((o.remaining_quantity for o in orders if o.price_ticks == comp and o.order_id in self.ahead)) >= (PROBE + 0.01 if QB and step == 1 else P['min_ahead']):\n                    return comp\n            elif self.s == 2:\n                if sticky and sum((o.remaining_quantity for o in orders if o.price_ticks == comp and o.order_id in self.ahead)) >= (P['min_ahead'] if self.s != 2 else max(P['min_ahead'], 400.0 / max(comp, 1))):\n                    return comp\n            elif self.s == 3:\n                threshold = max(P['min_ahead'], 20 * 100.0 / comp) if self.s == 3 and step == -1 and (1 <= comp <= 5) else P['min_ahead']\n                if sticky and sum((o.remaining_quantity for o in orders if o.price_ticks == comp and o.order_id in self.ahead)) >= threshold:\n                    return comp\n            elif self.s == 4:\n                if sticky and sum((o.remaining_quantity for o in orders if o.price_ticks == comp and o.order_id in self.ahead)) >= (ma_ask if step < 0 else P['min_ahead']):\n                    return comp\n            return comp + step\n        bid_t = top(bids, cb, 1)\n        ask_t = top(asks, ca, -1)\n        qb = qbid(bid_t)\n        if self.s == 2:\n            s2f = self.s == 2 and bid_t == cb and (qb > 0) and (cb / 100.0 < phat)\n        elif self.s == 4:\n            if phat < 0.05 and bid_t >= 2:\n                qb *= 0.5\n        qa = qask(ask_t)\n        if self.s == 1:\n            if ask_t == 2 and ask_t < ca and (phat < 0.01):\n                qa *= 5\n        Y = state.yes_inventory\n        if ask_t == 1 and H > P['H1'] and (P['pre'] > 0):\n            qa = qa if Y >= P['a1'] > 0 else 0.0\n        ptick = phat * 100\n        if self.s == 1:\n            flow_scale = max(0.4, min(1.9, 1.0 + 0.5 * (self.fl_rate / 0.568734 - 1))) if FL else 1.0\n        amt = 0\n        qam = 0.0\n        if P['ammo'] > 0 and ask_t >= 2 and (phat < max(P['ammo_pmax'], P['pmaxf'])):\n            wealth = state.cash + Y * phat\n            x = max(ask_t, ptick + 1) / 100.0\n            capw = P['fy'] * wealth / max(phat, 0.005)\n            if self.s == 1:\n                target = min(flow_scale * P['ydem'] * min(H, P['W']) / x, capw)\n                full = min(flow_scale * P['ydf'] * min(H, P['Wf']) / x, capw) if phat < P['pmaxf'] else 0.0\n            elif self.s == 2:\n                target = min(P['ydem'] * min(H, P['W']) / x, capw)\n                full = min(P['ydf'] * min(H, P['Wf']) / x, capw) if phat < P['pmaxf'] else 0.0\n            elif self.s == 3:\n                flow_scale = self.f4_flow / 0.6 if self.s == 4 else 1.0\n                target = min(flow_scale * P['ydem'] * min(H, P['W']) / x, capw)\n                target = min(target, qa)\n                full = min(flow_scale * P['ydf'] * min(H, P['Wf']) / x, capw) if phat < P['pmaxf'] else 0.0\n            elif self.s == 4:\n                flow_scale = self.f4_flow / 0.6 if self.s == 4 else 1.0\n                target = min(flow_scale * P['ydem'] * min(H, P['W']) / x, capw)\n                full = min(flow_scale * P['ydf'] * min(H, P['Wf']) / x, capw) if phat < P['pmaxf'] else 0.0\n            t = max(1, min(99, int(math.ceil(ptick + 1e-09))))\n            g = t - ptick\n            if Y < full and g <= P['g_hi'] and (bid_t <= t < ask_t):\n                amt, qam = (t, min(P['qf'], full - Y))\n            elif Y < target and phat < P['ammo_pmax'] and (bid_t <= t < ask_t) and (t / 100.0 - phat < P['ammo_maxpay']):\n                amt, qam = (t, min(P['ammo_q'], target - Y))\n            elif Y < full and t >= 2 and (1.0 - g <= P['g_lo']):\n                amt, qam = (t - 1, min(P['qf'], full - Y))\n        if P['pre'] > 0 and ca == 2 and (phat < 0.01) and (H > P['H1']) and (Y < P['pre']) and (not qam) and (1.0 - ptick < P['pre_gap']):\n            amt, qam = (1, min(P['ammo_q'], P['pre'] - Y))\n        q1 = 0.0\n        if P['ydf1'] > 0 and P['m1'] < ptick < P['g1'] + 1.0 and (amt != 1):\n            if self.s == 1:\n                stock_rate = flow_scale * P['ydf1']\n            elif self.s == 2:\n                stock_rate = P['ydf1']\n                flow = (self.flow_notional + P['flow_prior'] * P['flow_level']) / (P['flow_prior'] + self.flow_exposure)\n                scale = max(0.5, min(2.0, flow / P['flow_level']))\n                stock_rate *= 1.0 + P['flow_strength'] * (scale - 1.0)\n            elif self.s == 3:\n                stock_rate = P['ydf1']\n                flow = (self.flow_notional + P['flow_prior'] * P['flow_level']) / (P['flow_prior'] + self.flow_exposure)\n                scale = max(0.5, min(2.0, flow / P['flow_level']))\n                stock_rate *= 1.0 + P['flow_strength'] * (scale - 1.0)\n            elif self.s == 4:\n                stock_rate = P['ydf1']\n                stock_rate *= self.f4_flow / 0.6\n            q1 = max(0.0, stock_rate * min(H, P['Wf']) / (self.s / 100.0) - Y)\n        if 0.02 < phat < 0.1:\n            ct = max(2, min(99, int(math.floor(ptick))))\n            wealth = state.cash + Y * phat\n            if self.s == 1:\n                goal = min(flow_scale * qa, 0.3 * max(wealth, 0.0) / phat)\n            elif self.s == 2:\n                goal = min(1 * qa, 0.3 * max(wealth, 0.0) / phat)\n            elif self.s == 3:\n                goal = min(1 * qa, 0.3 * max(wealth, 0.0) / phat)\n            elif self.s == 4:\n                goal = min(1 * qa, 0.3 * max(wealth, 0.0) / phat)\n            if Y < goal and ct < ask_t:\n                amt, qam = (ct, min(3000.0, goal - Y))\n        if self.s == 1:\n            if SB and 2 <= amt <= 5:\n                amt, qam = (0, 0.0)\n        actions = []\n        free = state.free_cash - 2.0\n        keep_ask = 0.0\n        new_b = []\n        new_a = []\n\n        def cancel(o):\n            nonlocal free\n            actions.append(CancelOrder(o.order_id))\n            x = o.price_ticks / 100.0\n            if o.side is Side.BUY:\n                free += x * o.remaining_quantity\n            else:\n                free += (1 - x) * min(self.res.get(o.order_id, 0.0), o.remaining_quantity)\n            self.ahead.discard(o.order_id)\n            self.res.pop(o.order_id, None)\n        for o in state.own_orders:\n            if o.remaining_quantity <= PROBE + 1e-09:\n                cancel(o)\n        kept_ids = set()\n\n        def manage(orders, t, q, comp):\n            kept = 0.0\n            if self.s == 1:\n                banked = {}\n                bound_t, bound_q = (t, q)\n            elif self.s == 2:\n                buy = comp == cb\n                held = {}\n                for o in orders:\n                    x = o.price_ticks\n                    gain = ptk - x if buy else x - ptk\n                    if x == t and q > 0 and (kept + o.remaining_quantity <= max(q * P['keep_hi'], 1.0) or (x == comp and o.order_id in self.ahead and (ptk <= 10.0) and (gain >= 0.0))):\n                        kept += o.remaining_quantity\n                        kept_ids.add(o.order_id)\n                        continue\n                    if x == comp and x != t and (o.order_id in self.ahead) and (gain >= 1.0):\n                        if x not in held:\n                            held[x] = [0.0, qbid(x) if buy else qask(x)]\n                        h = held[x]\n                        if h[0] + o.remaining_quantity <= max(h[1], 1.0) and h[1] > 0:\n                            h[0] += o.remaining_quantity\n                            kept_ids.add(o.order_id)\n                            continue\n                    cancel(o)\n                return kept\n            for o in orders:\n                if self.s == 1:\n                    ah = o.order_id in self.ahead\n                    if AH and ah and (o.remaining_quantity >= P['min_ahead']) and (o.price_ticks != t):\n                        if o.side is Side.SELL and o.price_ticks > t or (o.side is Side.BUY and o.price_ticks < t):\n                            enough = bound_q > 0 and (o.remaining_quantity <= bound_q if o.side is Side.BUY else o.remaining_quantity * o.price_ticks <= min(bound_q, P['qmax']) * bound_t)\n                            if enough:\n                                kept_ids.add(o.order_id)\n                                continue\n                            if o.price_ticks == bound_t:\n                                capacity = bound_q\n                            else:\n                                capacity = qask(o.price_ticks) if o.side is Side.SELL else qbid(o.price_ticks)\n                                bound_t, bound_q = (o.price_ticks, capacity)\n                            if capacity > 0 and o.remaining_quantity <= max(capacity, 1.0):\n                                kept_ids.add(o.order_id)\n                                continue\n                    if QB and ah and (o.side is Side.BUY) and (o.price_ticks < t) and (banked.get(o.price_ticks, 0.0) + o.remaining_quantity <= P['keep_hi'] * qbid(o.price_ticks)):\n                        banked[o.price_ticks] = banked.get(o.price_ticks, 0.0) + o.remaining_quantity\n                        kept_ids.add(o.order_id)\n                        continue\n                    khi = 10.0 if AH and ah else P['keep_hi']\n                    if o.price_ticks == t and q > 0 and (kept + o.remaining_quantity <= max(q * khi, 1.0) or (s1 and ah and (o.side is Side.SELL) and (o.price_ticks <= 2)) or (LK and ah) or (QB and ah and (o.side is Side.BUY) and (o.price_ticks == comp))):\n                        kept += o.remaining_quantity\n                        kept_ids.add(o.order_id)\n                    else:\n                        cancel(o)\n                elif self.s == 2:\n                    if o.price_ticks == t and q > 0 and (kept + o.remaining_quantity <= max(q * P['keep_hi'], 1.0)):\n                        kept += o.remaining_quantity\n                        kept_ids.add(o.order_id)\n                    else:\n                        cancel(o)\n                elif self.s == 3:\n                    if o.price_ticks == t and q > 0 and (kept + o.remaining_quantity <= max(q * P['keep_hi'], 1.0)):\n                        kept += o.remaining_quantity\n                        kept_ids.add(o.order_id)\n                    else:\n                        cancel(o)\n                elif self.s == 4:\n                    if o.price_ticks == t and q > 0 and (kept + o.remaining_quantity <= max(q * (3.0 if self.s == 4 and o.side is Side.SELL and (o.order_id in self.ahead) and (o.price_ticks == comp) else P['keep_hi']), 1.0)):\n                        kept += o.remaining_quantity\n                        kept_ids.add(o.order_id)\n                    else:\n                        cancel(o)\n            return kept\n        if self.s == 1:\n            kb = manage(bids, bid_t, qb, cb)\n        elif self.s == 2:\n            if s2f and 1:\n                kb = 0.0\n                for o in bids:\n                    if o.price_ticks == bid_t and o.order_id in self.ahead:\n                        kb += o.remaining_quantity\n                        kept_ids.add(o.order_id)\n                    else:\n                        cancel(o)\n            elif 1 and bid_t == cb + 1:\n                qf = qbid(cb) if 1 else 1.0\n                fr = [o for o in bids if o.price_ticks == cb and o.order_id in self.ahead and (cb / 100.0 < phat - 0.0) and (qf > 0)]\n                for o in fr:\n                    kept_ids.add(o.order_id)\n                kb = manage([o for o in bids if o not in fr], bid_t, qb, cb)\n            else:\n                kb = manage(bids, bid_t, qb, cb)\n        elif self.s == 3:\n            kb = manage(bids, bid_t, qb, cb)\n        elif self.s == 4:\n            kb = manage(bids, bid_t, qb, cb)\n        ka = manage(asks, ask_t, qa, ca)\n        add_b = qb - kb if kb < qb * P['keep_lo'] and bid_t != cb else 0.0\n        add_a = qa - ka if ka < qa * P['keep_lo'] and ask_t != ca else 0.0\n        if self.s == 4 and add_a > 0:\n            sparse = max(0.0, 1.0 - sum(self.f4_exposure) / 200.0)\n            scale = 1.0 - sparse * (1.0 - self.f4_ask_lower_mean / self.f4_mean)\n            add_a = max(0.0, qa * scale - ka)\n        budget = P['fb'] * max(free, 0.0)\n        cost = add_b * bid_t / 100.0 + qam * amt / 100.0\n        if cost > budget:\n            f = budget / cost\n            add_b *= f\n            qam *= f\n            cost = budget\n        out = []\n        q1 = min(q1, P['f1'] * max(budget - cost, 0.0) * 100.0)\n        if q1 >= 0.01:\n            out.append(PlaceOrder(side=Side.BUY, price_ticks=1, quantity=fl(q1)))\n            free -= fl(q1) / 100.0 + 1e-06\n        if amt and qam >= 0.01:\n            q = fl(qam)\n            if self.s == 1:\n                if QB:\n                    oid = self._oid('m')\n                    out.append(PlaceOrder(side=Side.BUY, price_ticks=amt, quantity=q, client_order_id=oid))\n                    if amt > cb:\n                        self.ahead.add(oid)\n                else:\n                    out.append(PlaceOrder(side=Side.BUY, price_ticks=amt, quantity=q))\n            elif self.s == 2:\n                out.append(PlaceOrder(side=Side.BUY, price_ticks=amt, quantity=q))\n            elif self.s == 3:\n                out.append(PlaceOrder(side=Side.BUY, price_ticks=amt, quantity=q))\n            elif self.s == 4:\n                out.append(PlaceOrder(side=Side.BUY, price_ticks=amt, quantity=q))\n            free -= q * amt / 100.0 + 1e-06\n        if bid_t >= 1 and add_b >= 0.01:\n            q = fl(add_b)\n            if self.s == 4:\n                total_q = q\n                if ca <= 99 and bid_t > cb and (bid_t == ca - 4) and (q >= 4.0) and (q * bid_t / 100 >= 4 * P['m']):\n                    head = fl(q / 2)\n                    oid = self._oid('b')\n                    out.append(PlaceOrder(side=Side.BUY, price_ticks=bid_t, quantity=head, client_order_id=oid))\n                    self.ahead.add(oid)\n                    q = fl(q - head)\n            oid = self._oid('b')\n            out.append(PlaceOrder(side=Side.BUY, price_ticks=bid_t, quantity=q, client_order_id=oid))\n            if self.s == 1:\n                free -= q * bid_t / 100.0 + 1e-06\n            elif self.s == 2:\n                free -= q * bid_t / 100.0 + 1e-06\n            elif self.s == 3:\n                free -= q * bid_t / 100.0 + 1e-06\n            elif self.s == 4:\n                free -= total_q * bid_t / 100.0 + 1e-06\n            if bid_t > cb:\n                self.ahead.add(oid)\n        if ask_t <= 99 and add_a >= 0.01:\n            x = ask_t / 100.0\n            covk = sum((o.remaining_quantity - min(self.res.get(o.order_id, 0.0), o.remaining_quantity) for o in asks if o.order_id in kept_ids))\n            cov = max(0.0, Y - covk - 0.1)\n            unc = max(0.0, add_a - cov)\n            if unc > 0:\n                ub = max(0.0, free - (1 - P['fu']) * max(state.cash, 0.0)) if x >= P['xu'] else 0.0\n                if H < P['Hu'] and phat < 0.05:\n                    ub = max(0.0, free * (1 - H / P['Hu']))\n                unc = min(unc, ub / (1 - x))\n            q = fl(min(add_a, cov + unc))\n            if q >= 0.01:\n                oid = self._oid('a')\n                out.append(PlaceOrder(side=Side.SELL, price_ticks=ask_t, quantity=q, client_order_id=oid))\n                r = max(0.0, q - cov)\n                self.res[oid] = r\n                free -= r * (1 - x) + 1e-06\n                if ask_t < ca:\n                    self.ahead.add(oid)\n        f = int(math.floor(ptick + 1e-09))\n        r = max(int(P['rmin']), int(math.ceil(2.0 * s * 100)))\n        self.pb = set()\n        self.pa = set()\n        if free > 1.0:\n            for t in range(f, f + r + 1):\n                if cb < t < ca and 1 <= t <= 99:\n                    out.append(PlaceOrder(side=Side.BUY, price_ticks=t, quantity=PROBE))\n                    self.pb.add(t)\n            for t in range(f + 1 - r, f + 2):\n                if cb < t < ca and 1 <= t <= 99:\n                    out.append(PlaceOrder(side=Side.SELL, price_ticks=t, quantity=PROBE))\n                    self.pa.add(t)\n        if self.s == 1:\n            if FL:\n                if not kept_ids and (not any((o.quantity > PROBE for o in out))):\n                    self.fl_obs = ()\n                    self.fl_ahead.clear()\n                    return actions + out\n                for i, o in enumerate(out):\n                    if o.client_order_id is None and o.quantity > PROBE:\n                        out[i] = PlaceOrder(side=o.side, price_ticks=o.price_ticks, quantity=o.quantity, client_order_id=self._oid('f'))\n                live = []\n                oldids = {o.order_id for o in state.own_orders if o.order_id in kept_ids}\n                self.fl_ahead.intersection_update(oldids)\n                for o in state.own_orders:\n                    if o.order_id in kept_ids and o.remaining_quantity > PROBE:\n                        live.append((o.side, o.price_ticks, o.remaining_quantity, o.order_id))\n                for o in out:\n                    if o.quantity > PROBE:\n                        live.append((o.side, o.price_ticks, o.quantity, o.client_order_id))\n                        if o.side is Side.SELL and o.price_ticks < ca or (o.side is Side.BUY and o.price_ticks > cb):\n                            self.fl_ahead.add(o.client_order_id)\n                obs = []\n                for buying, side, comp in ((True, Side.SELL, ca), (False, Side.BUY, cb)):\n                    orders = [o for o in live if o[0] is side]\n                    if not orders:\n                        continue\n                    tick = min((o[1] for o in orders)) if buying else max((o[1] for o in orders))\n                    orders = [o for o in orders if o[1] == tick]\n                    if not all((o[3] in self.fl_ahead for o in orders)):\n                        continue\n                    if buying and tick > comp or (not buying and tick < comp):\n                        continue\n                    px = tick / 100.0 if buying else max(phat, 0.05)\n                    cap = sum((o[2] for o in orders)) * px\n                    if cap < 0.04:\n                        continue\n                    ci = 0\n                    while ci + 1 < len(FLOW_CAPS) and FLOW_CAPS[ci + 1] < cap - 0.01:\n                        ci += 1\n                    obs.append((px, ci, buying, [(o[3], o[2]) for o in orders], tick))\n                self.fl_obs = obs\n        elif self.s == 2:\n            self.last_ask_tick = ask_t\n            self.last_flow_ca = ca\n            exposed_qty = ka + sum((o.quantity for o in out if o.side is Side.SELL and o.price_ticks == ask_t and (o.quantity > PROBE)))\n            self.last_flow_cap = exposed_qty * ask_t / 100.0\n            self.last_quote_exposed = ask_t / 100.0 > phat + max(0.005, P['flow_safety'] * self.st / 100.0) and self.last_flow_cap >= P['flow_exposure_min']\n            if self.last_quote_exposed:\n                logcap = math.log(self.last_flow_cap)\n                mu_flow = math.log(P['m']) - 0.5 * P['sig_n'] ** 2\n                clipped = P['m'] * cdf((logcap - mu_flow - P['sig_n'] ** 2) / P['sig_n']) + self.last_flow_cap * (1.0 - cdf((logcap - mu_flow) / P['sig_n']))\n                self.last_flow_correction = min(3.0, P['m'] / max(clipped, 0.01))\n        elif self.s == 3:\n            self.last_ask_tick = ask_t\n            self.last_flow_ca = ca\n            exposed_qty = ka + sum((o.quantity for o in out if o.side is Side.SELL and o.price_ticks == ask_t and (o.quantity > PROBE)))\n            self.last_flow_cap = exposed_qty * ask_t / 100.0\n            self.last_quote_exposed = ask_t / 100.0 > phat + max(0.005, P['flow_safety'] * self.st / 100.0) and self.last_flow_cap >= P['flow_exposure_min']\n            if self.last_quote_exposed:\n                logcap = math.log(self.last_flow_cap)\n                mu_flow = math.log(P['m']) - 0.5 * P['sig_n'] ** 2\n                clipped = P['m'] * cdf((logcap - mu_flow - P['sig_n'] ** 2) / P['sig_n']) + self.last_flow_cap * (1.0 - cdf((logcap - mu_flow) / P['sig_n']))\n                self.last_flow_correction = min(3.0, P['m'] / max(clipped, 0.01))\n        elif self.s == 4:\n            self.f4_last = [None, None]\n            for side, tick, bound, conv, distance in ((0, ask_t, ca, ask_t / 100.0, ask_t / 100.0 - phat), (1, bid_t, cb, max(phat, 0.05), phat - bid_t / 100.0)):\n                if distance < max(0.01, 3.0 * self.st / 100.0):\n                    continue\n                if side == 0:\n                    if not (ask_t < ca or any((o.price_ticks == ask_t and o.order_id in self.ahead for o in asks))):\n                        continue\n                    orders = asks\n                    order_side = Side.SELL\n                else:\n                    if not (bid_t > cb or any((o.price_ticks == bid_t and o.order_id in self.ahead for o in bids))):\n                        continue\n                    if qam > 0 and amt >= bid_t or (q1 > 0 and bid_t <= 1):\n                        continue\n                    orders = bids\n                    order_side = Side.BUY\n                tracked = {o.order_id: o.remaining_quantity for o in orders if o.order_id in kept_ids and o.price_ticks == tick}\n                tracked.update({o.client_order_id: o.quantity for o in out if o.side is order_side and o.price_ticks == tick and (o.client_order_id is not None)})\n                cap = sum(tracked.values()) * conv\n                if cap >= 0.5:\n                    self.f4_last[side] = (tick, conv, cap, bound, tracked)\n        return actions + out\n","code_sha256":"120ca4121b17c5b56982d8c6258d9edf1db9985e3119eb66d7b0d956629f2d63","incumbent_code_sha256":"bf0d179f3e47d28819f6fa7e0d25548c2ced43374c216d36460b00a26a26ffae","target_spreads":[4],"tuning":{"seed_start":310000,"seed_end_inclusive":310199,"expected_n":200,"complete":true,"missing_seeds":[],"failed_seeds":[],"B_failed_count":0,"C_failed_count":0,"B_all_failed_flags_false":true,"C_all_failed_flags_false":true,"spread_label_mismatch_seeds":[],"non_target_nonzero_seeds":[],"overall":{"n":200,"sum_d":7.9187467026000995,"sum_d2":91.26159726900839,"mean_diff":0.039593733513000495,"se":0.04780300460540361,"C_mean_edge":85.202246898555,"B_mean_edge":85.16265316504199,"retail_diff":0.008119149331000362,"arb_diff":0.03147458418500005},"by_spread":{"1":{"n":47,"sum_d":0.0,"sum_d2":0.0,"mean_diff":0.0,"se":0.0,"C_mean_edge":30.59600304578298,"B_mean_edge":30.59600304578298,"retail_diff":0.0,"arb_diff":0.0},"2":{"n":57,"sum_d":0.0,"sum_d2":0.0,"mean_diff":0.0,"se":0.0,"C_mean_edge":81.35713208259824,"B_mean_edge":81.35713208259824,"retail_diff":0.0,"arb_diff":0.0},"3":{"n":53,"sum_d":0.0,"sum_d2":0.0,"mean_diff":0.0,"se":0.0,"C_mean_edge":115.06691980369057,"B_mean_edge":115.06691980369057,"retail_diff":0.0,"arb_diff":0.0},"4":{"n":43,"sum_d":7.9187467026000995,"sum_d2":91.26159726900839,"mean_diff":0.18415690006046742,"se":0.2229909758662231,"C_mean_edge":113.17520833152325,"B_mean_edge":112.9910514314628,"retail_diff":0.0377634852604668,"arb_diff":0.1463934148139537}}},"paired":{"seed_start":410000,"seed_end_inclusive":410499,"expected_n":500,"complete":true,"missing_seeds":[],"failed_seeds":[],"B_failed_count":0,"C_failed_count":0,"B_all_failed_flags_false":true,"C_all_failed_flags_false":true,"spread_label_mismatch_seeds":[],"non_target_nonzero_seeds":[],"overall":{"n":500,"sum_d":16.559981069300136,"sum_d2":184.42867576606233,"mean_diff":0.03311996213860027,"se":0.027147648681570945,"C_mean_edge":104.44687315028541,"B_mean_edge":104.4137531881468,"retail_diff":-0.007379862829399585,"arb_diff":0.04049982497039996},"by_spread":{"1":{"n":115,"sum_d":0.0,"sum_d2":0.0,"mean_diff":0.0,"se":0.0,"C_mean_edge":28.495154459731307,"B_mean_edge":28.495154459731307,"retail_diff":0.0,"arb_diff":0.0},"2":{"n":116,"sum_d":0.0,"sum_d2":0.0,"mean_diff":0.0,"se":0.0,"C_mean_edge":97.76626247947758,"B_mean_edge":97.76626247947758,"retail_diff":0.0,"arb_diff":0.0},"3":{"n":138,"sum_d":0.0,"sum_d2":0.0,"mean_diff":0.0,"se":0.0,"C_mean_edge":128.4054514027384,"B_mean_edge":128.4054514027384,"retail_diff":0.0,"arb_diff":0.0},"4":{"n":131,"sum_d":16.559981069300136,"sum_d2":184.42867576606233,"mean_diff":0.12641206923129875,"se":0.10347323977786185,"C_mean_edge":151.79889367233818,"B_mean_edge":151.67248160310686,"retail_diff":-0.028167415379387727,"arb_diff":0.15457948461984716}}},"complete":true,"failures":[],"seconds_per_simulation":1.4437718254371015,"timing":{"mean_all":1.4437718254371015,"simulation_count":1400,"total_measured_simulation_seconds":2021.280555611942,"first_10_assigned_pairs":{"seeds":[310000,310001,310002,310003,310004,310005,310006,310007,310008,310009],"B_seconds":[1.6543986522592604,1.489793705753982,1.423706372268498,1.3858930333517492,1.6014639888890088,1.0524396048858762,1.4547480130568147,1.523141574114561,1.6032810332253575,1.7615779130719602],"C_seconds":[1.637497569900006,1.5129103269428015,1.4418581258505583,1.4590034689754248,1.5145241161808372,1.0980370319448411,1.4416722878813744,1.555164473131299,1.5673475582152605,1.7407440561801195],"seconds_per_simulation":1.4959601453039795,"retained_once_in_tuning":true}},"local_checks":{"code_parses":true,"all_spread_setup_functions_unchanged":true,"synthetic_identical_state_check":"PASS: lower new ask quantity only; non-sell actions and learned posterior unchanged; identical actions at 200 exposures.","strategy_dependencies":"math plus simulator strategy/types only","execution":"T and H used successive serial Python invocations; only one simulation process active at any time."},"simulator_commit":"b244530ee2a6247b5f930830eeca9dd950da0e7e","reproduction":{"method":"Use Python 3 standard library and the unmodified pinned simulator. Extract JSON.code from the incumbent URL as B.py and this result as C.py. Import Strategy from each. For every assigned seed in increasing order, cfg=sample_config(ChallengeConfig(),ParameterVariance(),seed=seed); run SimulationEngine(cfg,B.Strategy,seed=seed).run(), then the same with C.Strategy, sequentially in one OS process, fresh instances, 2000 steps. No sandbox, multiprocessing or workers. Observe the first callback competitor quotes through a wrapper: s=max(1,((ask or 100)-(bid or 0)+1)//2); verify against cfg.competitor.spread_ticks and result.regime.competitor_spread_ticks. Retain all results including failed flags/errors. T precedes freeze and H runs once. No finalist seeds were run.","statistics":"d=C.total_edge-B.total_edge; sum_d=fsum(d), sum_d2=fsum(d*d), mean_diff=sum_d/n, se=sqrt(max(0,(sum_d2-sum_d**2/n)/(n-1))/n). Retail and arb differences are signed mean C-B, not absolute values. C/B means include every returned result; any failed or missing run makes complete false. Per-spread groups use the first observed rival spread.","sources_file":"sources.json"},"scoreboard":{"current_best":"B","current_best_code_sha256":"bf0d179f3e47d28819f6fa7e0d25548c2ced43374c216d36460b00a26a26ffae","candidate_code_sha256":"120ca4121b17c5b56982d8c6258d9edf1db9985e3119eb66d7b0d956629f2d63","tuning_paired_mean_diff":0.039593733513000495,"tuning_paired_se":0.04780300460540361,"screening_paired_mean_diff":0.03311996213860027,"screening_paired_se":0.027147648681570945,"promoted":false}}