{"key":"c-s4-flowscales-tail","idea":"combine the f-flow-scales overlay with s4-uncertainty-tail (spread 4 only)","approach":"Start from N, apply the s4-uncertainty-tail change verbatim (SHA 120ca412...), then graft f-flow-scales overlay (SHA 32f15d36...) as an on_step post-step (subclass). When self.s == 4 it hides and cancels its own extra orders, reconstructs the resting quotes from the returned actions and, after step 192, adds one extra order per side at the best own price sized FLOW_SIZE*size*min(1, short/long-1) when the 24-step fill EMA exceeds 1.35x the 192-step EMA, capped at FLOW_CAP notional and free cash. Otherwise on_step is the inherited step. Variants: frozen (0.3, 20); halved (0.15, 10).","tried":[{"name":"V1_as_frozen","code_sha256":"2711d665c72e0b629231bd67ed9120c3288245b2d7702822c4e7a80598723ff1","tuning_mean_diff":0.026616993206000132,"se":0.024069003588841828,"spread4_mean_diff":0.1023730507923082,"spread4_se":0.09242324741509446},{"name":"V2_overlay_halved","code_sha256":"40ce1972d62fe43e1cb127edb582744e8ce2b21b2052f350fb430a743de51069","tuning_mean_diff":0.026616993206000132,"se":0.024069003588841828,"spread4_mean_diff":0.1023730507923082,"spread4_se":0.09242324741509446},{"name":"T_tail_only_reference","code_sha256":"120ca4121b17c5b56982d8c6258d9edf1db9985e3119eb66d7b0d956629f2d63","tuning_mean_diff":0.026616993213500053,"se":0.024069003588607543,"spread4_mean_diff":0.10237305082115405,"spread4_se":0.09242324741371519,"note":"reference only: s4-uncertainty-tail without the overlay, run on the same tuning seeds to isolate the overlay"}],"next":"Do not promote and do not pursue this graft further: the frozen overlay sizes its extra order off the best-priced own quote, which at spread 4 is almost always a 0.01 probe, so it fired on only 3 of 116 spread-4 holdout seeds and the measured difference is the tail change alone (0.0036 +/- 0.0063 overall).","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\nfrom dataclasses import replace as _flow_replace\nfrom orderbook_pm_challenge.types import PlaceOrder as _FlowPlace, CancelOrder as _FlowCancel, CancelAll as _FlowCancelAll, Side as _FlowSide\nimport math as _flow_math\n\n_Tail = Strategy\n\nclass Strategy(_Tail):\n    # f-flow-scales overlay grafted as an on_step post-step. It acts only when self.s == 4.\n    FLOW_SIZE = 0.3\n    FLOW_CAP = 20.0\n\n    def __init__(self):\n        _Tail.__init__(self)\n        self._flow_short = [0.0, 0.0]\n        self._flow_long = [0.0, 0.0]\n        self._flow_serial = 0\n        self._flow_ids = set()\n\n    def _flow_observe(self, state):\n        for i, value in enumerate((state.buy_filled_quantity, state.sell_filled_quantity)):\n            self._flow_short[i] += (value - self._flow_short[i]) / 24.0\n            self._flow_long[i] += (value - self._flow_long[i]) / 192.0\n\n    def on_step(self, state):\n        if self.s is None:\n            # First callback: the inherited step reads the rival's spread into self.s.\n            # No overlay order exists yet and the overlay places nothing before step 192.\n            first_actions = _Tail.on_step(self, state)\n            if self.s == 4:\n                self._flow_observe(state)\n            return first_actions\n        if self.s != 4:\n            return _Tail.on_step(self, state)\n        self._flow_observe(state)\n        extras = tuple(o for o in state.own_orders if o.order_id in self._flow_ids)\n        native = tuple(o for o in state.own_orders if o.order_id not in self._flow_ids)\n        base_actions = list(_Tail.on_step(self, _flow_replace(state, own_orders=native)))\n        actions = [_FlowCancel(o.order_id) for o in extras] + base_actions\n        self._flow_ids.clear()\n        # Reconstruct the inherited step's resting quotes from its public actions.\n        projected = {o.order_id: (o.side, o.price_ticks, o.remaining_quantity) for o in native}\n        pending = []\n        budget = max(0.0, state.free_cash)\n        for action in base_actions:\n            if isinstance(action, _FlowCancelAll):\n                projected.clear()\n                pending.clear()\n            elif isinstance(action, _FlowCancel):\n                projected.pop(action.order_id, None)\n                pending = [(key, v) for key, v in pending if key != action.order_id]\n            elif isinstance(action, _FlowPlace):\n                pending.append((action.client_order_id, (action.side, action.price_ticks, action.quantity)))\n                unit = action.price_ticks / 100.0 if action.side == _FlowSide.BUY else 1.0 - action.price_ticks / 100.0\n                budget -= unit * action.quantity\n        # Ignore all collateral released by cancellations: conservative free-cash bound.\n        budget = max(0.0, budget)\n        quotes = list(projected.values()) + [v for _, v in pending]\n        if state.step < 192:\n            return actions\n        for i, side in enumerate((_FlowSide.BUY, _FlowSide.SELL)):\n            short, long = self._flow_short[i], self._flow_long[i]\n            if short <= 1.35 * long or long < 0.02:\n                continue\n            own = [q for q in quotes if q[0] == side]\n            if not own:\n                continue\n            price = (max if side == _FlowSide.BUY else min)(q[1] for q in own)\n            size = sum(q[2] for q in own if q[1] == price)\n            unit = price / 100.0 if side == _FlowSide.BUY else 1.0 - price / 100.0\n            desired = size * self.FLOW_SIZE * min(1.0, short / long - 1.0)\n            quantity = _flow_math.floor(min(desired, self.FLOW_CAP / unit, budget / unit) * 100.0) / 100.0\n            if quantity < 0.01:\n                continue\n            self._flow_serial += 1\n            oid = '__flow_scales_extra_' + str(self._flow_serial)\n            self._flow_ids.add(oid)\n            actions.append(_FlowPlace(side, price, quantity, oid))\n            budget = max(0.0, budget - unit * quantity)\n        return actions\n","code_sha256":"2711d665c72e0b629231bd67ed9120c3288245b2d7702822c4e7a80598723ff1","incumbent_code_sha256":"bf0d179f3e47d28819f6fa7e0d25548c2ced43374c216d36460b00a26a26ffae","target_spreads":[4],"tuning":{"seeds":{"start":320000,"end_inclusive":320199,"n":200},"selected":"V1_as_frozen","selection_rule":"V1 and V2 returned bit-identical total, retail and arb edge and fill counts on all 200 tuning seeds (the overlay changed no outcome at either size), so the tie goes to the brief-named default, as frozen. T (tail only) also differs from V1 on one seed (320120) by -1.5e-09 only.","variants":{"V1_as_frozen":{"code_sha256":"2711d665c72e0b629231bd67ed9120c3288245b2d7702822c4e7a80598723ff1","FLOW_SIZE":0.3,"FLOW_CAP":20.0,"paired_vs_N":{"n":200,"complete":true,"missing_seeds":[],"overall":{"n":200,"sum_d":5.3233986412000265,"sum_d2":23.19850682910095,"mean_diff":0.026616993206000132,"se":0.024069003588841828,"incumbent_mean":98.47071831456549,"candidate_mean":98.4973353077715,"retail_diff":0.0028386492605006453,"arb_diff":0.023778343954499938},"by_spread":{"1":{"n":50,"sum_d":0.0,"sum_d2":0.0,"mean_diff":0.0,"se":0.0,"incumbent_mean":25.711261479664,"candidate_mean":25.711261479664,"retail_diff":0.0,"arb_diff":0.0},"2":{"n":50,"sum_d":0.0,"sum_d2":0.0,"mean_diff":0.0,"se":0.0,"incumbent_mean":61.219908510538,"candidate_mean":61.219908510538,"retail_diff":0.0,"arb_diff":0.0},"3":{"n":48,"sum_d":0.0,"sum_d2":0.0,"mean_diff":0.0,"se":0.0,"incumbent_mean":130.8342429047854,"candidate_mean":130.8342429047854,"retail_diff":0.0,"arb_diff":0.0},"4":{"n":52,"sum_d":5.3233986412000265,"sum_d2":23.19850682910095,"mean_diff":0.1023730507923082,"se":0.09242324741509446,"incumbent_mean":174.37579815333268,"candidate_mean":174.47817120412498,"retail_diff":0.010917881771156327,"arb_diff":0.09145516905576899}}}},"V2_overlay_halved":{"code_sha256":"40ce1972d62fe43e1cb127edb582744e8ce2b21b2052f350fb430a743de51069","FLOW_SIZE":0.15,"FLOW_CAP":10.0,"paired_vs_N":{"n":200,"complete":true,"missing_seeds":[],"overall":{"n":200,"sum_d":5.3233986412000265,"sum_d2":23.19850682910095,"mean_diff":0.026616993206000132,"se":0.024069003588841828,"incumbent_mean":98.47071831456549,"candidate_mean":98.4973353077715,"retail_diff":0.0028386492605006453,"arb_diff":0.023778343954499938},"by_spread":{"1":{"n":50,"sum_d":0.0,"sum_d2":0.0,"mean_diff":0.0,"se":0.0,"incumbent_mean":25.711261479664,"candidate_mean":25.711261479664,"retail_diff":0.0,"arb_diff":0.0},"2":{"n":50,"sum_d":0.0,"sum_d2":0.0,"mean_diff":0.0,"se":0.0,"incumbent_mean":61.219908510538,"candidate_mean":61.219908510538,"retail_diff":0.0,"arb_diff":0.0},"3":{"n":48,"sum_d":0.0,"sum_d2":0.0,"mean_diff":0.0,"se":0.0,"incumbent_mean":130.8342429047854,"candidate_mean":130.8342429047854,"retail_diff":0.0,"arb_diff":0.0},"4":{"n":52,"sum_d":5.3233986412000265,"sum_d2":23.19850682910095,"mean_diff":0.1023730507923082,"se":0.09242324741509446,"incumbent_mean":174.37579815333268,"candidate_mean":174.47817120412498,"retail_diff":0.010917881771156327,"arb_diff":0.09145516905576899}}}},"T_tail_only_reference":{"code_sha256":"120ca4121b17c5b56982d8c6258d9edf1db9985e3119eb66d7b0d956629f2d63","note":"s4-uncertainty-tail alone (overlay effect zero); reference, not eligible for selection","paired_vs_N":{"n":200,"complete":true,"missing_seeds":[],"overall":{"n":200,"sum_d":5.323398642700011,"sum_d2":23.198506828731933,"mean_diff":0.026616993213500053,"se":0.024069003588607543,"incumbent_mean":98.47071831456549,"candidate_mean":98.497335307779,"retail_diff":0.0028386492605006453,"arb_diff":0.023778343961999928},"by_spread":{"1":{"n":50,"sum_d":0.0,"sum_d2":0.0,"mean_diff":0.0,"se":0.0,"incumbent_mean":25.711261479664,"candidate_mean":25.711261479664,"retail_diff":0.0,"arb_diff":0.0},"2":{"n":50,"sum_d":0.0,"sum_d2":0.0,"mean_diff":0.0,"se":0.0,"incumbent_mean":61.219908510538,"candidate_mean":61.219908510538,"retail_diff":0.0,"arb_diff":0.0},"3":{"n":48,"sum_d":0.0,"sum_d2":0.0,"mean_diff":0.0,"se":0.0,"incumbent_mean":130.8342429047854,"candidate_mean":130.8342429047854,"retail_diff":0.0,"arb_diff":0.0},"4":{"n":52,"sum_d":5.323398642700011,"sum_d2":23.198506828731933,"mean_diff":0.10237305082115405,"se":0.09242324741371519,"incumbent_mean":174.37579815333268,"candidate_mean":174.47817120415385,"retail_diff":0.010917881771156327,"arb_diff":0.09145516908461511}}}}},"diagnostics":{"V1_vs_V2_seeds_with_any_difference":0,"V1_vs_T":{"overall":{"n":200,"sum_d":-1.4999841368990019e-09,"sum_d2":2.2499524109486437e-18,"mean_diff":-7.49992068449501e-12,"se":7.49992068449501e-12,"incumbent_mean":98.497335307779,"candidate_mean":98.4973353077715,"retail_diff":0.0,"arb_diff":-7.499991738768585e-12},"seeds_with_nonzero_d":1},"spread_counts":{"1":50,"2":50,"3":48,"4":52},"off_target_seeds_with_nonzero_d":0}},"paired":{"seeds":{"start":430000,"end_inclusive":430499,"n":500},"n":500,"complete":true,"missing_seeds":[],"overall":{"n":500,"sum_d":1.822196065599984,"sum_d2":9.867475733536283,"mean_diff":0.003644392131199968,"se":0.006286683109173195,"incumbent_mean":95.54201511346659,"candidate_mean":95.5456595055978,"retail_diff":-0.013065499641799832,"arb_diff":0.01670989177359985},"by_spread":{"1":{"n":131,"sum_d":0.0,"sum_d2":0.0,"mean_diff":0.0,"se":0.0,"incumbent_mean":38.277936657049615,"candidate_mean":38.277936657049615,"retail_diff":0.0,"arb_diff":0.0},"2":{"n":120,"sum_d":0.0,"sum_d2":0.0,"mean_diff":0.0,"se":0.0,"incumbent_mean":77.8558643979175,"candidate_mean":77.8558643979175,"retail_diff":0.0,"arb_diff":0.0},"3":{"n":133,"sum_d":0.0,"sum_d2":0.0,"mean_diff":0.0,"se":0.0,"incumbent_mean":146.55140363646615,"candidate_mean":146.55140363646615,"retail_diff":0.0,"arb_diff":0.0},"4":{"n":116,"sum_d":1.822196065599984,"sum_d2":9.867475733536283,"mean_diff":0.015708586772413654,"se":0.02715778153845071,"incumbent_mean":120.02204692465259,"candidate_mean":120.03775551142499,"retail_diff":-0.056316808800861345,"arb_diff":0.07202539557586142}},"spread_4_seeds_with_nonzero_d":114,"off_target_seeds_with_nonzero_d":0,"spread_labels_consistent":true,"overlay_fired":{"seeds":[{"seed":430108,"spread":4,"overlay_orders":34,"overlay_steps":31,"overlay_quantity":70.81,"fill_count_diff":-1,"d":0.06851704119999624},{"seed":430277,"spread":4,"overlay_orders":29,"overlay_steps":29,"overlay_quantity":2453.91,"fill_count_diff":37,"d":-0.3756341381999846},{"seed":430448,"spread":4,"overlay_orders":1,"overlay_steps":1,"overlay_quantity":18.02,"fill_count_diff":0,"d":0.11732686080000221}],"count":3,"spread_4_seeds":116,"how_counted":"passive wrapper in the runner counted PlaceOrder actions whose client_order_id starts with __flow_scales_extra_; N placed none; d on these seeds includes the tail change"},"verdict":"screen only, never a promotion; gain 0.0036 +/- 0.0063 overall, 0.0157 +/- 0.0272 on spread 4, both under 1 SE"},"failures":[],"check_values":{"seeds":[310000,310001,310002,310003],"N_total_edge":[17.1160017503,20.0171113118,2.3903113616,241.4847522404],"expected":[17.116002,20.017111,2.390311,241.484752],"match":true},"python_version":"3.12.3","seconds_per_simulation":0.6099710290462245,"seconds_per_simulation_all_runs":0.5878139535157978,"simulations_run":{"check":4,"tuning":800,"holdout":1000,"each_seed_strategy_pair_once":true,"serial":true,"workers":false,"sandbox":false,"steps":2000,"simulator_commit":"b244530ee2a6247b5f930830eeca9dd950da0e7e"},"statistics":"d = candidate minus N total edge per seed; se = sample sd of d / sqrt(n); retail_diff and arb_diff are per-seed mean differences; spread = sampled config competitor.spread_ticks (equal to regime and to the first-step observed spread on every seed)","local_checks":{"graft_equals_verbatim_overlay":"seedless deterministic driver of the real order book: with a stub base that quotes real size at the best price (spread 4), the grafted subclass and T-with-verbatim-overlay (composition, FLOW_SPREADS=(4,)) returned identical action sequences and stats with 42 extra orders each; on spreads 1-3 both equal the base alone with 0 extras","candidate_equals_N_off_target":"same driver: V1, V2 and T equal N action-by-action at spreads 1, 2 and 3; on tuning and holdout every off-target seed has d exactly 0","why_overlay_rarely_fires":"in the same driver N at spread 4 kept 0.01 probe orders at its best own price, so the overlay desired size (0.3*0.01*m) floors to 0 and no extra order is placed"}}